Use Gradle

src/main/java/org/schabi/newpipe/extractor/Downloader.java

@@ -0,0 +1,61 @@
+package org.schabi.newpipe.extractor;
+
+import org.schabi.newpipe.extractor.exceptions.ReCaptchaException;
+
+import java.io.IOException;
+import java.util.Map;
+
+/*
+ * Created by Christian Schabesberger on 28.01.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * Downloader.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public interface Downloader {
+
+    /**
+     * Download the text file at the supplied URL as in download(String),
+     * but set the HTTP header field "Accept-Language" to the supplied string.
+     *
+     * @param siteUrl  the URL of the text file to return the contents of
+     * @param language the language (usually a 2-character code) to set as the preferred language
+     * @return the contents of the specified text file
+     * @throws IOException
+     */
+    String download(String siteUrl, String language) throws IOException, ReCaptchaException;
+
+    /**
+     * Download the text file at the supplied URL as in download(String),
+     * but set the HTTP header field "Accept-Language" to the supplied string.
+     *
+     * @param siteUrl          the URL of the text file to return the contents of
+     * @param customProperties set request header properties
+     * @return the contents of the specified text file
+     * @throws IOException
+     */
+    String download(String siteUrl, Map<String, String> customProperties) throws IOException, ReCaptchaException;
+
+    /**
+     * Download (via HTTP) the text file located at the supplied URL, and return its contents.
+     * Primarily intended for downloading web pages.
+     *
+     * @param siteUrl the URL of the text file to download
+     * @return the contents of the specified text file
+     * @throws IOException
+     */
+    String download(String siteUrl) throws IOException, ReCaptchaException;
+}

src/main/java/org/schabi/newpipe/extractor/Extractor.java

@@ -0,0 +1,35 @@
+package org.schabi.newpipe.extractor;
+
+import org.schabi.newpipe.extractor.stream.StreamInfoItemCollector;
+
+import java.io.Serializable;
+
+public abstract class Extractor implements Serializable {
+    private final int serviceId;
+    private final String url;
+    private final UrlIdHandler urlIdHandler;
+    private final StreamInfoItemCollector previewInfoCollector;
+
+    public Extractor(UrlIdHandler urlIdHandler, int serviceId, String url) {
+        this.urlIdHandler = urlIdHandler;
+        this.serviceId = serviceId;
+        this.url = url;
+        this.previewInfoCollector = new StreamInfoItemCollector(serviceId);
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public UrlIdHandler getUrlIdHandler() {
+        return urlIdHandler;
+    }
+
+    public int getServiceId() {
+        return serviceId;
+    }
+
+    protected StreamInfoItemCollector getStreamPreviewInfoCollector() {
+        return previewInfoCollector;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/Info.java

@@ -0,0 +1,19 @@
+package org.schabi.newpipe.extractor;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Vector;
+
+public abstract class Info implements Serializable {
+
+    public int service_id = -1;
+    /**
+     * Id of this Info object <br>
+     * e.g. Youtube:  https://www.youtube.com/watch?v=RER5qCTzZ7     >    RER5qCTzZ7
+     */
+    public String id;
+    public String url;
+    public String name;
+
+    public List<Throwable> errors = new Vector<>();
+}

src/main/java/org/schabi/newpipe/extractor/InfoItem.java

@@ -0,0 +1,40 @@
+package org.schabi.newpipe.extractor;
+
+/*
+ * Created by the-scrabi on 11.02.17.
+ *
+ * Copyright (C) Christian Schabesberger 2017 <chris.schabesberger@mailbox.org>
+ * InfoItem.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import java.io.Serializable;
+
+public abstract class InfoItem implements Serializable {
+    public enum InfoType {
+        STREAM,
+        PLAYLIST,
+        CHANNEL
+    }
+
+    public InfoItem(InfoType infoType) {
+        this.info_type = infoType;
+    }
+
+    public final InfoType info_type;
+    public int service_id = -1;
+    public String url;
+    public String name;
+}

src/main/java/org/schabi/newpipe/extractor/InfoItemCollector.java

@@ -0,0 +1,66 @@
+package org.schabi.newpipe.extractor;
+
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+
+import java.util.List;
+import java.util.Vector;
+
+/*
+ * Created by Christian Schabesberger on 12.02.17.
+ *
+ * Copyright (C) Christian Schabesberger 2017 <chris.schabesberger@mailbox.org>
+ * InfoItemCollector.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public abstract class InfoItemCollector {
+    private List<InfoItem> itemList = new Vector<>();
+    private List<Throwable> errors = new Vector<>();
+    private int serviceId = -1;
+
+    public InfoItemCollector(int serviceId) {
+        this.serviceId = serviceId;
+    }
+
+    public List<InfoItem> getItemList() {
+        return itemList;
+    }
+
+    public List<Throwable> getErrors() {
+        return errors;
+    }
+
+    protected void addFromCollector(InfoItemCollector otherC) throws ExtractionException {
+        if (serviceId != otherC.serviceId) {
+            throw new ExtractionException("Service Id does not equal: "
+                    + NewPipe.getNameOfService(serviceId)
+                    + " and " + NewPipe.getNameOfService(otherC.serviceId));
+        }
+        errors.addAll(otherC.errors);
+        itemList.addAll(otherC.itemList);
+    }
+
+    protected void addError(Exception e) {
+        errors.add(e);
+    }
+
+    protected void addItem(InfoItem item) {
+        itemList.add(item);
+    }
+
+    protected int getServiceId() {
+        return serviceId;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/ListExtractor.java

@@ -0,0 +1,32 @@
+package org.schabi.newpipe.extractor;
+
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemCollector;
+
+import java.io.IOException;
+
+/**
+ * Base class to extractors that have a list (e.g. playlists, channels).
+ */
+public abstract class ListExtractor extends Extractor {
+    protected String nextStreamsUrl;
+
+    public ListExtractor(UrlIdHandler urlIdHandler, int serviceId, String url) {
+        super(urlIdHandler, serviceId, url);
+    }
+
+    public boolean hasMoreStreams(){
+        return nextStreamsUrl != null && !nextStreamsUrl.isEmpty();
+    }
+
+    public abstract StreamInfoItemCollector getNextStreams() throws ExtractionException, IOException;
+
+    public String getNextStreamsUrl() {
+        return nextStreamsUrl;
+    }
+
+    public void setNextStreamsUrl(String nextStreamsUrl) {
+        this.nextStreamsUrl = nextStreamsUrl;
+    }
+
+}

src/main/java/org/schabi/newpipe/extractor/MediaFormat.java

@@ -0,0 +1,108 @@
+package org.schabi.newpipe.extractor;
+
+/*
+ * Created by Adam Howard on 08/11/15.
+ *
+ * Copyright (c) Christian Schabesberger <chris.schabesberger@mailbox.org>
+ *     and Adam Howard <achdisposable1@gmail.com> 2015
+ *
+ * MediaFormat.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Static data about various media formats support by Newpipe, eg mime type, extension
+ */
+
+public enum MediaFormat {
+    //video and audio combined formats
+    //           id      name    suffix  mime type
+    MPEG_4      (0x0,   "MPEG-4", "mp4", "video/mp4"),
+    v3GPP       (0x1,   "3GPP",   "3gp", "video/3gpp"),
+    WEBM        (0x2,   "WebM",  "webm", "video/webm"),
+    // audio formats
+    M4A         (0x3,   "m4a",   "m4a",  "audio/mp4"),
+    WEBMA       (0x4,   "WebM",  "webm", "audio/webm"),
+    MP3         (0x5,   "MP3",   "mp3",  "audio/mpeg");
+
+    public final int id;
+    @SuppressWarnings("WeakerAccess")
+    public final String name;
+    @SuppressWarnings("WeakerAccess")
+    public final String suffix;
+    public final String mimeType;
+
+    MediaFormat(int id, String name, String suffix, String mimeType) {
+        this.id = id;
+        this.name = name;
+        this.suffix = suffix;
+        this.mimeType = mimeType;
+    }
+
+    /**
+     * Return the friendly name of the media format with the supplied id
+     *
+     * @param ident the id of the media format. Currently an arbitrary, NewPipe-specific number.
+     * @return the friendly name of the MediaFormat associated with this ids,
+     * or an empty String if none match it.
+     */
+    public static String getNameById(int ident) {
+        for (MediaFormat vf : MediaFormat.values()) {
+            if (vf.id == ident) return vf.name;
+        }
+        return "";
+    }
+
+    /**
+     * Return the file extension of the media format with the supplied id
+     *
+     * @param ident the id of the media format. Currently an arbitrary, NewPipe-specific number.
+     * @return the file extension of the MediaFormat associated with this ids,
+     * or an empty String if none match it.
+     */
+    public static String getSuffixById(int ident) {
+        for (MediaFormat vf : MediaFormat.values()) {
+            if (vf.id == ident) return vf.suffix;
+        }
+        return "";
+    }
+
+    /**
+     * Return the MIME type of the media format with the supplied id
+     *
+     * @param ident the id of the media format. Currently an arbitrary, NewPipe-specific number.
+     * @return the MIME type of the MediaFormat associated with this ids,
+     * or an empty String if none match it.
+     */
+    public static String getMimeById(int ident) {
+        for (MediaFormat vf : MediaFormat.values()) {
+            if (vf.id == ident) return vf.mimeType;
+        }
+        return "";
+    }
+
+    /**
+     * Return the MediaFormat with the supplied mime type
+     *
+     * @return MediaFormat associated with this mime type,
+     * or null if none match it.
+     */
+    public static MediaFormat getFromMimeType(String mimeType) {
+        for (MediaFormat vf : MediaFormat.values()) {
+            if (vf.mimeType.equals(mimeType)) return vf;
+        }
+        return null;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/NewPipe.java

@@ -0,0 +1,91 @@
+package org.schabi.newpipe.extractor;
+
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+
+/*
+ * Created by Christian Schabesberger on 23.08.15.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * NewPipe.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Provides access to the video streaming services supported by NewPipe.
+ * Currently only Youtube until the API becomes more stable.
+ */
+
+@SuppressWarnings("ALL")
+public class NewPipe {
+    private static final String TAG = NewPipe.class.toString();
+
+    private NewPipe() {
+    }
+
+    private static Downloader downloader = null;
+
+    public static StreamingService[] getServices() {
+        return ServiceList.serviceList;
+    }
+
+    public static StreamingService getService(int serviceId) throws ExtractionException {
+        for (StreamingService s : ServiceList.serviceList) {
+            if (s.getServiceId() == serviceId) {
+                return s;
+            }
+        }
+        return null;
+    }
+
+    public static StreamingService getService(String serviceName) throws ExtractionException {
+        return ServiceList.serviceList[getIdOfService(serviceName)];
+    }
+
+    public static String getNameOfService(int id) {
+        try {
+            return getService(id).getServiceInfo().name;
+        } catch (Exception e) {
+            System.err.println("Service id not known");
+            e.printStackTrace();
+            return "";
+        }
+    }
+
+    public static int getIdOfService(String serviceName) {
+        for (int i = 0; i < ServiceList.serviceList.length; i++) {
+            if (ServiceList.serviceList[i].getServiceInfo().name.equals(serviceName)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public static void init(Downloader d) {
+        downloader = d;
+    }
+
+    public static Downloader getDownloader() {
+        return downloader;
+    }
+
+    public static StreamingService getServiceByUrl(String url) {
+        for (StreamingService s : ServiceList.serviceList) {
+            if (s.getLinkTypeByUrl(url) != StreamingService.LinkType.NONE) {
+                return s;
+            }
+        }
+        return null;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/ServiceList.java

@@ -0,0 +1,15 @@
+package org.schabi.newpipe.extractor;
+
+import org.schabi.newpipe.extractor.services.youtube.YoutubeService;
+import org.schabi.newpipe.extractor.services.soundcloud.SoundcloudService;
+
+/*
+ * Created by the-scrabi on 18.02.17.
+ */
+
+class ServiceList {
+    public static final StreamingService[] serviceList = {
+            new YoutubeService(0),
+            new SoundcloudService(1)
+    };
+}

src/main/java/org/schabi/newpipe/extractor/StreamingService.java

@@ -0,0 +1,63 @@
+package org.schabi.newpipe.extractor;
+
+import org.schabi.newpipe.extractor.channel.ChannelExtractor;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.playlist.PlaylistExtractor;
+import org.schabi.newpipe.extractor.search.SearchEngine;
+import org.schabi.newpipe.extractor.stream.StreamExtractor;
+
+import java.io.IOException;
+
+public abstract class StreamingService {
+    public class ServiceInfo {
+        public String name = "";
+    }
+
+    public enum LinkType {
+        NONE,
+        STREAM,
+        CHANNEL,
+        PLAYLIST
+    }
+
+    private int serviceId;
+
+    public StreamingService(int id) {
+        serviceId = id;
+    }
+
+    public abstract ServiceInfo getServiceInfo();
+
+    public abstract UrlIdHandler getStreamUrlIdHandlerInstance();
+    public abstract UrlIdHandler getChannelUrlIdHandlerInstance();
+    public abstract UrlIdHandler getPlaylistUrlIdHandlerInstance();
+    public abstract SearchEngine getSearchEngineInstance();
+    public abstract SuggestionExtractor getSuggestionExtractorInstance();
+    public abstract StreamExtractor getStreamExtractorInstance(String url) throws IOException, ExtractionException;
+    public abstract ChannelExtractor getChannelExtractorInstance(String url) throws ExtractionException, IOException;
+    public abstract PlaylistExtractor getPlaylistExtractorInstance(String url) throws ExtractionException, IOException;
+
+
+    public final int getServiceId() {
+        return serviceId;
+    }
+
+    /**
+     * figure out where the link is pointing to (a channel, video, playlist, etc.)
+     */
+    public final LinkType getLinkTypeByUrl(String url) {
+        UrlIdHandler sH = getStreamUrlIdHandlerInstance();
+        UrlIdHandler cH = getChannelUrlIdHandlerInstance();
+        UrlIdHandler pH = getPlaylistUrlIdHandlerInstance();
+
+        if (sH.acceptUrl(url)) {
+            return LinkType.STREAM;
+        } else if (cH.acceptUrl(url)) {
+            return LinkType.CHANNEL;
+        } else if (pH.acceptUrl(url)) {
+            return LinkType.PLAYLIST;
+        } else {
+            return LinkType.NONE;
+        }
+    }
+}

src/main/java/org/schabi/newpipe/extractor/SuggestionExtractor.java

@@ -0,0 +1,42 @@
+package org.schabi.newpipe.extractor;
+
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+
+import java.io.IOException;
+import java.util.List;
+
+/*
+ * Created by Christian Schabesberger on 28.09.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * SuggestionExtractor.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public abstract class SuggestionExtractor {
+
+    private int serviceId;
+
+    public SuggestionExtractor(int serviceId) {
+        this.serviceId = serviceId;
+    }
+
+    public abstract List<String> suggestionList(String query, String contentCountry)
+            throws ExtractionException, IOException;
+
+    public int getServiceId() {
+        return serviceId;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/UrlIdHandler.java

@@ -0,0 +1,40 @@
+package org.schabi.newpipe.extractor;
+
+import java.io.IOException;
+
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.exceptions.ReCaptchaException;
+
+/*
+ * Created by Christian Schabesberger on 26.07.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * UrlIdHandler.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public interface UrlIdHandler {
+
+    String getUrl(String videoId) throws ParsingException;
+    String getId(String siteUrl) throws ParsingException;
+    String cleanUrl(String siteUrl) throws ParsingException;
+
+    /**
+     * When a VIEW_ACTION is caught this function will test if the url delivered within the calling
+     * Intent was meant to be watched with this Service.
+     * Return false if this service shall not allow to be called through ACTIONs.
+     */
+    boolean acceptUrl(String videoUrl);
+}

src/main/java/org/schabi/newpipe/extractor/channel/ChannelExtractor.java

@@ -0,0 +1,46 @@
+package org.schabi.newpipe.extractor.channel;
+
+import org.schabi.newpipe.extractor.ListExtractor;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+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.stream.StreamInfoItemCollector;
+
+import java.io.IOException;
+
+/*
+ * Created by Christian Schabesberger on 25.07.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * ChannelExtractor.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public abstract class ChannelExtractor extends ListExtractor {
+
+    public ChannelExtractor(UrlIdHandler urlIdHandler, String url, int serviceId) throws ExtractionException, IOException {
+        super(urlIdHandler, serviceId, url);
+    }
+
+    public abstract String getChannelId() throws ParsingException;
+    public abstract String getChannelName() throws ParsingException;
+    public abstract String getAvatarUrl() throws ParsingException;
+    public abstract String getBannerUrl() throws ParsingException;
+    public abstract String getFeedUrl() throws ParsingException;
+    public abstract StreamInfoItemCollector getStreams() throws ParsingException, ReCaptchaException, IOException;
+    public abstract long getSubscriberCount() throws ParsingException;
+
+}

src/main/java/org/schabi/newpipe/extractor/channel/ChannelInfo.java

@@ -0,0 +1,79 @@
+package org.schabi.newpipe.extractor.channel;
+
+import org.schabi.newpipe.extractor.Info;
+import org.schabi.newpipe.extractor.InfoItem;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemCollector;
+
+import java.util.List;
+
+/*
+ * Created by Christian Schabesberger on 31.07.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * ChannelInfo.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class ChannelInfo extends Info {
+
+    public static ChannelInfo getInfo(ChannelExtractor extractor) throws ParsingException {
+        ChannelInfo info = new ChannelInfo();
+
+        // important data
+        info.service_id = extractor.getServiceId();
+        info.url = extractor.getUrl();
+        info.id = extractor.getChannelId();
+        info.name = extractor.getChannelName();
+        info.has_more_streams = extractor.hasMoreStreams();
+
+        try {
+            info.avatar_url = extractor.getAvatarUrl();
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+        try {
+            info.banner_url = extractor.getBannerUrl();
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+        try {
+            info.feed_url = extractor.getFeedUrl();
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+        try {
+            StreamInfoItemCollector c = extractor.getStreams();
+            info.related_streams = c.getItemList();
+            info.errors.addAll(c.getErrors());
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+        try {
+            info.subscriber_count = extractor.getSubscriberCount();
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+
+        return info;
+    }
+
+    public String avatar_url;
+    public String banner_url;
+    public String feed_url;
+    public List<InfoItem> related_streams;
+    public long subscriber_count = -1;
+    public boolean has_more_streams = false;
+}

src/main/java/org/schabi/newpipe/extractor/channel/ChannelInfoItem.java

@@ -0,0 +1,35 @@
+package org.schabi.newpipe.extractor.channel;
+
+import org.schabi.newpipe.extractor.InfoItem;
+
+/*
+ * Created by Christian Schabesberger on 11.02.17.
+ *
+ * Copyright (C) Christian Schabesberger 2017 <chris.schabesberger@mailbox.org>
+ * ChannelInfoItem.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class ChannelInfoItem extends InfoItem {
+
+    public String thumbnail_url;
+    public String description;
+    public long subscriber_count = -1;
+    public long view_count = -1;
+
+    public ChannelInfoItem() {
+        super(InfoType.CHANNEL);
+    }
+}

src/main/java/org/schabi/newpipe/extractor/channel/ChannelInfoItemCollector.java

@@ -0,0 +1,70 @@
+package org.schabi.newpipe.extractor.channel;
+
+import org.schabi.newpipe.extractor.InfoItemCollector;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+
+/*
+ * Created by Christian Schabesberger on 12.02.17.
+ *
+ * Copyright (C) Christian Schabesberger 2017 <chris.schabesberger@mailbox.org>
+ * ChannelInfoItemCollector.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class ChannelInfoItemCollector extends InfoItemCollector {
+    public ChannelInfoItemCollector(int serviceId) {
+        super(serviceId);
+    }
+
+    public ChannelInfoItem extract(ChannelInfoItemExtractor extractor) throws ParsingException {
+        ChannelInfoItem resultItem = new ChannelInfoItem();
+        // important information
+        resultItem.name = extractor.getChannelName();
+
+        resultItem.service_id = getServiceId();
+        resultItem.url = extractor.getWebPageUrl();
+
+        // optional information
+        try {
+            resultItem.subscriber_count = extractor.getSubscriberCount();
+        } catch (Exception e) {
+            addError(e);
+        }
+        try {
+            resultItem.view_count = extractor.getViewCount();
+        } catch (Exception e) {
+            addError(e);
+        }
+        try {
+            resultItem.thumbnail_url = extractor.getThumbnailUrl();
+        } catch (Exception e) {
+            addError(e);
+        }
+        try {
+            resultItem.description = extractor.getDescription();
+        } catch (Exception e) {
+            addError(e);
+        }
+        return resultItem;
+    }
+
+    public void commit(ChannelInfoItemExtractor extractor) throws ParsingException {
+        try {
+            addItem(extract(extractor));
+        } catch (Exception e) {
+            addError(e);
+        }
+    }
+}

src/main/java/org/schabi/newpipe/extractor/channel/ChannelInfoItemExtractor.java

@@ -0,0 +1,32 @@
+package org.schabi.newpipe.extractor.channel;
+
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+
+/*
+ * Created by Christian Schabesberger on 12.02.17.
+ *
+ * Copyright (C) Christian Schabesberger 2017 <chris.schabesberger@mailbox.org>
+ * ChannelInfoItemExtractor.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public interface ChannelInfoItemExtractor {
+    String getThumbnailUrl() throws ParsingException;
+    String getChannelName() throws ParsingException;
+    String getWebPageUrl() throws ParsingException;
+    String getDescription() throws ParsingException;
+    long getSubscriberCount() throws ParsingException;
+    long getViewCount() throws ParsingException;
+}

src/main/java/org/schabi/newpipe/extractor/exceptions/ContentNotAvailableException.java

@@ -0,0 +1,11 @@
+package org.schabi.newpipe.extractor.exceptions;
+
+public class ContentNotAvailableException extends ParsingException {
+    public ContentNotAvailableException(String message) {
+        super(message);
+    }
+
+    public ContentNotAvailableException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/org/schabi/newpipe/extractor/exceptions/ExtractionException.java

@@ -0,0 +1,35 @@
+package org.schabi.newpipe.extractor.exceptions;
+
+/*
+ * Created by Christian Schabesberger on 30.01.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * ExtractionException.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class ExtractionException extends Exception {
+    public ExtractionException(String message) {
+        super(message);
+    }
+
+    public ExtractionException(Throwable cause) {
+        super(cause);
+    }
+
+    public ExtractionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/org/schabi/newpipe/extractor/exceptions/FoundAdException.java

@@ -0,0 +1,31 @@
+package org.schabi.newpipe.extractor.exceptions;
+
+/*
+ * Created by Christian Schabesberger on 12.09.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * FoundAdException.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class FoundAdException extends ParsingException {
+    public FoundAdException(String message) {
+        super(message);
+    }
+
+    public FoundAdException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/org/schabi/newpipe/extractor/exceptions/ParsingException.java

@@ -0,0 +1,32 @@
+package org.schabi.newpipe.extractor.exceptions;
+
+/*
+ * Created by Christian Schabesberger on 31.01.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * ParsingException.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+public class ParsingException extends ExtractionException {
+    public ParsingException(String message) {
+        super(message);
+    }
+
+    public ParsingException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/org/schabi/newpipe/extractor/exceptions/ReCaptchaException.java

@@ -0,0 +1,27 @@
+package org.schabi.newpipe.extractor.exceptions;
+
+/*
+ * Created by beneth <bmauduit@beneth.fr> on 07.12.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * ReCaptchaException.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class ReCaptchaException extends ExtractionException {
+    public ReCaptchaException(String message) {
+        super(message);
+    }
+}

src/main/java/org/schabi/newpipe/extractor/playlist/PlaylistExtractor.java

@@ -0,0 +1,27 @@
+package org.schabi.newpipe.extractor.playlist;
+
+import org.schabi.newpipe.extractor.ListExtractor;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+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.stream.StreamInfoItemCollector;
+
+import java.io.IOException;
+
+public abstract class PlaylistExtractor extends ListExtractor {
+
+    public PlaylistExtractor(UrlIdHandler urlIdHandler, String url, int serviceId) throws ExtractionException, IOException {
+        super(urlIdHandler, serviceId, url);
+    }
+
+    public abstract String getPlaylistId() throws ParsingException;
+    public abstract String getPlaylistName() throws ParsingException;
+    public abstract String getAvatarUrl() throws ParsingException;
+    public abstract String getBannerUrl() throws ParsingException;
+    public abstract String getUploaderUrl() throws ParsingException;
+    public abstract String getUploaderName() throws ParsingException;
+    public abstract String getUploaderAvatarUrl() throws ParsingException;
+    public abstract StreamInfoItemCollector getStreams() throws ParsingException, ReCaptchaException, IOException;
+    public abstract long getStreamsCount() throws ParsingException;
+}

src/main/java/org/schabi/newpipe/extractor/playlist/PlaylistInfo.java

@@ -0,0 +1,70 @@
+package org.schabi.newpipe.extractor.playlist;
+
+import org.schabi.newpipe.extractor.Info;
+import org.schabi.newpipe.extractor.InfoItem;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemCollector;
+
+import java.util.List;
+
+public class PlaylistInfo extends Info {
+
+    public static PlaylistInfo getInfo(PlaylistExtractor extractor) throws ParsingException {
+        PlaylistInfo info = new PlaylistInfo();
+
+        info.service_id = extractor.getServiceId();
+        info.url = extractor.getUrl();
+        info.id = extractor.getPlaylistId();
+        info.name = extractor.getPlaylistName();
+        info.has_more_streams = extractor.hasMoreStreams();
+
+        try {
+            info.streams_count = extractor.getStreamsCount();
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+        try {
+            info.avatar_url = extractor.getAvatarUrl();
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+        try {
+            info.uploader_url = extractor.getUploaderUrl();
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+        try {
+            info.uploader_name = extractor.getUploaderName();
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+        try {
+            info.uploader_avatar_url = extractor.getUploaderAvatarUrl();
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+        try {
+            info.banner_url = extractor.getBannerUrl();
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+        try {
+            StreamInfoItemCollector c = extractor.getStreams();
+            info.related_streams = c.getItemList();
+            info.errors.addAll(c.getErrors());
+        } catch (Exception e) {
+            info.errors.add(e);
+        }
+
+        return info;
+    }
+
+    public String avatar_url;
+    public String banner_url;
+    public String uploader_url;
+    public String uploader_name;
+    public String uploader_avatar_url;
+    public long streams_count = 0;
+    public List<InfoItem> related_streams;
+    public boolean has_more_streams;
+}

src/main/java/org/schabi/newpipe/extractor/playlist/PlaylistInfoItem.java

@@ -0,0 +1,16 @@
+package org.schabi.newpipe.extractor.playlist;
+
+import org.schabi.newpipe.extractor.InfoItem;
+
+public class PlaylistInfoItem extends InfoItem {
+
+    public String thumbnail_url;
+    /**
+     * How many streams this playlist have
+     */
+    public long streams_count = 0;
+
+    public PlaylistInfoItem() {
+        super(InfoType.PLAYLIST);
+    }
+}

src/main/java/org/schabi/newpipe/extractor/playlist/PlaylistInfoItemCollector.java

@@ -0,0 +1,39 @@
+package org.schabi.newpipe.extractor.playlist;
+
+import org.schabi.newpipe.extractor.InfoItemCollector;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+
+public class PlaylistInfoItemCollector extends InfoItemCollector {
+    public PlaylistInfoItemCollector(int serviceId) {
+        super(serviceId);
+    }
+
+    public PlaylistInfoItem extract(PlaylistInfoItemExtractor extractor) throws ParsingException {
+        final PlaylistInfoItem resultItem = new PlaylistInfoItem();
+
+        resultItem.name = extractor.getPlaylistName();
+        resultItem.service_id = getServiceId();
+        resultItem.url = extractor.getWebPageUrl();
+
+        try {
+            resultItem.thumbnail_url = extractor.getThumbnailUrl();
+        } catch (Exception e) {
+            addError(e);
+        }
+        try {
+            resultItem.streams_count = extractor.getStreamsCount();
+        } catch (Exception e) {
+            addError(e);
+        }
+        return resultItem;
+    }
+
+    public void commit(PlaylistInfoItemExtractor extractor) throws ParsingException {
+        try {
+            addItem(extract(extractor));
+        } catch (Exception e) {
+            addError(e);
+        }
+    }
+}

src/main/java/org/schabi/newpipe/extractor/playlist/PlaylistInfoItemExtractor.java

@@ -0,0 +1,10 @@
+package org.schabi.newpipe.extractor.playlist;
+
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+
+public interface PlaylistInfoItemExtractor {
+    String getThumbnailUrl() throws ParsingException;
+    String getPlaylistName() throws ParsingException;
+    String getWebPageUrl() throws ParsingException;
+    long getStreamsCount() throws ParsingException;
+}

src/main/java/org/schabi/newpipe/extractor/search/InfoItemSearchCollector.java

@@ -0,0 +1,77 @@
+package org.schabi.newpipe.extractor.search;
+
+import org.schabi.newpipe.extractor.InfoItemCollector;
+import org.schabi.newpipe.extractor.channel.ChannelInfoItemCollector;
+import org.schabi.newpipe.extractor.channel.ChannelInfoItemExtractor;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.exceptions.FoundAdException;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemCollector;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemExtractor;
+
+/*
+ * Created by Christian Schabesberger on 12.02.17.
+ *
+ * Copyright (C) Christian Schabesberger 2017 <chris.schabesberger@mailbox.org>
+ * InfoItemSearchCollector.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class InfoItemSearchCollector extends InfoItemCollector {
+    private String suggestion;
+    private StreamInfoItemCollector streamCollector;
+    private ChannelInfoItemCollector channelCollector;
+
+    private SearchResult result = new SearchResult();
+
+    InfoItemSearchCollector(int serviceId) {
+        super(serviceId);
+        streamCollector = new StreamInfoItemCollector(serviceId);
+        channelCollector = new ChannelInfoItemCollector(serviceId);
+    }
+
+    public void setSuggestion(String suggestion) {
+        this.suggestion = suggestion;
+    }
+
+    public SearchResult getSearchResult() throws ExtractionException {
+
+        addFromCollector(channelCollector);
+        addFromCollector(streamCollector);
+
+        result.suggestion = suggestion;
+        result.errors = getErrors();
+        return result;
+    }
+
+    public void commit(StreamInfoItemExtractor extractor) {
+        try {
+            result.resultList.add(streamCollector.extract(extractor));
+        } catch (FoundAdException ae) {
+            System.err.println("Found add");
+        } catch (Exception e) {
+            addError(e);
+        }
+    }
+
+    public void commit(ChannelInfoItemExtractor extractor) {
+        try {
+            result.resultList.add(channelCollector.extract(extractor));
+        } catch (FoundAdException ae) {
+            System.err.println("Found add");
+        } catch (Exception e) {
+            addError(e);
+        }
+    }
+}

src/main/java/org/schabi/newpipe/extractor/search/SearchEngine.java

@@ -0,0 +1,53 @@
+package org.schabi.newpipe.extractor.search;
+
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+
+import java.io.IOException;
+import java.util.EnumSet;
+
+/*
+ * Created by Christian Schabesberger on 10.08.15.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * SearchEngine.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public abstract class SearchEngine {
+    public enum Filter {
+        STREAM, CHANNEL, PLAYLIST
+    }
+
+    public static class NothingFoundException extends ExtractionException {
+        public NothingFoundException(String message) {
+            super(message);
+        }
+    }
+
+    private InfoItemSearchCollector collector;
+
+    public SearchEngine(int serviceId) {
+        collector = new InfoItemSearchCollector(serviceId);
+    }
+
+    protected InfoItemSearchCollector getInfoItemSearchCollector() {
+        return collector;
+    }
+
+    //Result search(String query, int page);
+    public abstract InfoItemSearchCollector search(
+            String query, int page, String contentCountry, EnumSet<Filter> filter)
+            throws ExtractionException, IOException;
+}

src/main/java/org/schabi/newpipe/extractor/search/SearchResult.java

@@ -0,0 +1,55 @@
+package org.schabi.newpipe.extractor.search;
+
+import org.schabi.newpipe.extractor.InfoItem;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+
+import java.io.IOException;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Vector;
+
+/*
+ * Created by Christian Schabesberger on 29.02.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * SearchResult.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class SearchResult {
+    public static SearchResult getSearchResult(SearchEngine engine, String query,
+                                               int page, String languageCode, EnumSet<SearchEngine.Filter> filter)
+            throws ExtractionException, IOException {
+
+        SearchResult result = engine
+                .search(query, page, languageCode, filter)
+                .getSearchResult();
+        if (result.resultList.isEmpty()) {
+            if (result.suggestion.isEmpty()) {
+                if (result.errors.isEmpty()) {
+                    throw new ExtractionException("Empty result despite no error");
+                }
+            } else {
+                // This is used as a fallback. Do not relay on it !!!
+                throw new SearchEngine.NothingFoundException(result.suggestion);
+            }
+        }
+        return result;
+    }
+
+    public String suggestion;
+    public List<InfoItem> resultList = new Vector<>();
+    public List<Throwable> errors = new Vector<>();
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudChannelExtractor.java

@@ -0,0 +1,118 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import java.io.IOException;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.channel.ChannelExtractor;
+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.stream.StreamInfoItemCollector;
+
+@SuppressWarnings("WeakerAccess")
+public class SoundcloudChannelExtractor extends ChannelExtractor {
+    private String channelId;
+    private JSONObject channel;
+    private String nextUrl;
+
+    public SoundcloudChannelExtractor(UrlIdHandler urlIdHandler, String url, int serviceId) throws ExtractionException, IOException {
+        super(urlIdHandler, url, serviceId);
+
+        Downloader dl = NewPipe.getDownloader();
+
+        channelId = urlIdHandler.getId(url);
+        String apiUrl = "https://api-v2.soundcloud.com/users/" + channelId
+                + "?client_id=" + SoundcloudParsingHelper.clientId();
+
+        String response = dl.download(apiUrl);
+        channel = new JSONObject(response);
+    }
+
+    @Override
+    public String getChannelId() {
+        return channelId;
+    }
+
+    @Override
+    public String getChannelName() {
+        return channel.getString("username");
+    }
+
+    @Override
+    public String getAvatarUrl() {
+        return channel.getString("avatar_url");
+    }
+
+    @Override
+    public String getBannerUrl() throws ParsingException {
+        try {
+            return channel.getJSONObject("visuals").getJSONArray("visuals").getJSONObject(0).getString("visual_url");
+        } catch (Exception e) {
+            throw new ParsingException("Could not get Banner", e);
+        }
+    }
+
+    @Override
+    public StreamInfoItemCollector getStreams() throws ReCaptchaException, IOException, ParsingException {
+        StreamInfoItemCollector collector = getStreamPreviewInfoCollector();
+        Downloader dl = NewPipe.getDownloader();
+
+        String apiUrl = "https://api-v2.soundcloud.com/users/" + channelId + "/tracks"
+                + "?client_id=" + SoundcloudParsingHelper.clientId()
+                + "&limit=10"
+                + "&offset=0"
+                + "&linked_partitioning=1";
+
+        String response = dl.download(apiUrl);
+        JSONObject responseObject = new JSONObject(response);
+
+        nextUrl = responseObject.getString("next_href")
+                + "&client_id=" + SoundcloudParsingHelper.clientId()
+                + "&linked_partitioning=1";
+
+        JSONArray responseCollection = responseObject.getJSONArray("collection");
+        for (int i = 0; i < responseCollection.length(); i++) {
+            JSONObject track = responseCollection.getJSONObject(i);
+            collector.commit(new SoundcloudStreamInfoItemExtractor(track));
+        }
+        return collector;
+    }
+
+    @Override
+    public long getSubscriberCount() {
+        return channel.getLong("followers_count");
+    }
+
+    @Override
+    public String getFeedUrl() throws ParsingException {
+        return null;
+    }
+
+    @Override
+    public StreamInfoItemCollector getNextStreams() throws ExtractionException, IOException {
+        if (nextUrl.equals("")) {
+            throw new ExtractionException("Channel doesn't have more streams");
+        }
+
+        StreamInfoItemCollector collector = getStreamPreviewInfoCollector();
+        Downloader dl = NewPipe.getDownloader();
+
+        String response = dl.download(nextUrl);
+        JSONObject responseObject = new JSONObject(response);
+
+        nextUrl = responseObject.getString("next_href")
+                + "&client_id=" + SoundcloudParsingHelper.clientId()
+                + "&linked_partitioning=1";
+
+        JSONArray responseCollection = responseObject.getJSONArray("collection");
+        for (int i = 0; i < responseCollection.length(); i++) {
+            JSONObject track = responseCollection.getJSONObject(i);
+            collector.commit(new SoundcloudStreamInfoItemExtractor(track));
+        }
+        return collector;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudChannelInfoItemExtractor.java

@@ -0,0 +1,42 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import org.json.JSONObject;
+import org.schabi.newpipe.extractor.channel.ChannelInfoItemExtractor;
+
+public class SoundcloudChannelInfoItemExtractor implements ChannelInfoItemExtractor {
+    private JSONObject searchResult;
+
+    public SoundcloudChannelInfoItemExtractor(JSONObject searchResult) {
+        this.searchResult = searchResult;
+    }
+
+    @Override
+    public String getThumbnailUrl() {
+        return searchResult.getString("avatar_url");
+    }
+
+    @Override
+    public String getChannelName() {
+        return searchResult.getString("username");
+    }
+
+    @Override
+    public String getWebPageUrl() {
+        return searchResult.getString("permalink_url");
+    }
+
+    @Override
+    public long getSubscriberCount() {
+        return searchResult.getLong("followers_count");
+    }
+
+    @Override
+    public long getViewCount() {
+        return searchResult.getLong("track_count");
+    }
+
+    @Override
+    public String getDescription() {
+        return searchResult.getString("description");
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudChannelUrlIdHandler.java

@@ -0,0 +1,76 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import org.json.JSONObject;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.utils.Parser;
+
+public class SoundcloudChannelUrlIdHandler implements UrlIdHandler {
+
+    private static final SoundcloudChannelUrlIdHandler instance = new SoundcloudChannelUrlIdHandler();
+
+    public static SoundcloudChannelUrlIdHandler getInstance() {
+        return instance;
+    }
+
+    @Override
+    public String getUrl(String channelId) throws ParsingException {
+        try {
+            Downloader dl = NewPipe.getDownloader();
+
+            String response = dl.download("https://api-v2.soundcloud.com/user/" + channelId
+                    + "?client_id=" + SoundcloudParsingHelper.clientId());
+            JSONObject responseObject = new JSONObject(response);
+
+            return responseObject.getString("permalink_url");
+        } catch (Exception e) {
+            throw new ParsingException(e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public String getId(String siteUrl) throws ParsingException {
+        try {
+            Downloader dl = NewPipe.getDownloader();
+
+            String response = dl.download(siteUrl);
+            Document doc = Jsoup.parse(response);
+
+            Element androidElement = doc.select("meta[property=al:android:url]").first();
+            String id = androidElement.attr("content").substring(19);
+
+            return id;
+        } catch (Exception e) {
+            throw new ParsingException(e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public String cleanUrl(String siteUrl) throws ParsingException {
+        try {
+            Downloader dl = NewPipe.getDownloader();
+
+            String response = dl.download(siteUrl);
+            Document doc = Jsoup.parse(response);
+
+            Element ogElement = doc.select("meta[property=og:url]").first();
+            String url = ogElement.attr("content");
+
+            return url;
+        } catch (Exception e) {
+            throw new ParsingException(e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public boolean acceptUrl(String channelUrl) {
+        String regex = "^https?://(www\\.)?soundcloud.com/[0-9a-z_-]+(/((tracks|albums|sets|reposts|followers|following)/?)?)?([#?].*)?$";
+        return Parser.isMatch(regex, channelUrl.toLowerCase());
+
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudParsingHelper.java

@@ -0,0 +1,80 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import java.io.IOException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.schabi.newpipe.extractor.Downloader;
+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.utils.Parser;
+import org.schabi.newpipe.extractor.utils.Parser.RegexException;
+
+public class SoundcloudParsingHelper {
+    private SoundcloudParsingHelper() {
+    }
+
+    public static final String clientId() throws ReCaptchaException, IOException, RegexException {
+        Downloader dl = NewPipe.getDownloader();
+
+        String response = dl.download("https://soundcloud.com");
+        Document doc = Jsoup.parse(response);
+
+        Element jsElement = doc.select("script[src^=https://a-v2.sndcdn.com/assets/app]").first();
+        String js = dl.download(jsElement.attr("src"));
+
+        String clientId = Parser.matchGroup1(",client_id:\"(.*?)\"", js);
+        return clientId;
+    }
+
+    public static String toTimeAgoString(String time) throws ParsingException {
+        try {
+            List<Long> times = Arrays.asList(TimeUnit.DAYS.toMillis(365), TimeUnit.DAYS.toMillis(30),
+                    TimeUnit.DAYS.toMillis(7), TimeUnit.HOURS.toMillis(1), TimeUnit.MINUTES.toMillis(1),
+                    TimeUnit.SECONDS.toMillis(1));
+            List<String> timesString = Arrays.asList("year", "month", "week", "day", "hour", "minute", "second");
+
+            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
+
+            long timeAgo = System.currentTimeMillis() - dateFormat.parse(time).getTime();
+
+            StringBuilder timeAgoString = new StringBuilder();
+
+            for (int i = 0; i < times.size(); i++) {
+                Long current = times.get(i);
+                long currentAmount = timeAgo / current;
+                if (currentAmount > 0) {
+                    timeAgoString.append(currentAmount).append(" ").append(timesString.get(i))
+                            .append(currentAmount != 1 ? "s ago" : " ago");
+                    break;
+                }
+            }
+            if (timeAgoString.toString().equals("")) {
+                timeAgoString.append("Just now");
+            }
+            return timeAgoString.toString();
+        } catch (ParseException e) {
+            throw new ParsingException(e.getMessage(), e);
+        }
+    }
+
+    public static String toDateString(String time) throws ParsingException {
+        try {
+            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
+            Date date = dateFormat.parse(time);
+            SimpleDateFormat newDateFormat = new SimpleDateFormat("yyyy-MM-dd");
+            return newDateFormat.format(date);
+        } catch (ParseException e) {
+            throw new ParsingException(e.getMessage(), e);
+        }
+    }
+
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudPlaylistExtractor.java

@@ -0,0 +1,129 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+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.playlist.PlaylistExtractor;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemCollector;
+
+@SuppressWarnings("WeakerAccess")
+public class SoundcloudPlaylistExtractor extends PlaylistExtractor {
+    private String playlistId;
+    private JSONObject playlist;
+    private List<String> nextTracks;
+
+    public SoundcloudPlaylistExtractor(UrlIdHandler urlIdHandler, String url, int serviceId) throws IOException, ExtractionException {
+        super(urlIdHandler, url, serviceId);
+
+        Downloader dl = NewPipe.getDownloader();
+        playlistId = urlIdHandler.getId(url);
+
+        String apiUrl = "https://api-v2.soundcloud.com/users/" + playlistId
+                + "?client_id=" + SoundcloudParsingHelper.clientId();
+
+        String response = dl.download(apiUrl);
+        playlist = new JSONObject(response);
+    }
+
+    @Override
+    public String getPlaylistId() {
+        return playlistId;
+    }
+
+    @Override
+    public String getPlaylistName() {
+        return playlist.getString("title");
+    }
+
+    @Override
+    public String getAvatarUrl() {
+        return playlist.getString("artwork_url");
+    }
+
+    @Override
+    public String getBannerUrl() {
+        return null;
+    }
+
+    @Override
+    public String getUploaderUrl() {
+        return playlist.getJSONObject("user").getString("permalink_url");
+    }
+
+    @Override
+    public String getUploaderName() {
+        return playlist.getJSONObject("user").getString("username");
+    }
+
+    @Override
+    public String getUploaderAvatarUrl() {
+        return playlist.getJSONObject("user").getString("avatar_url");
+    }
+
+    @Override
+    public long getStreamsCount() {
+        return playlist.getLong("track_count");
+    }
+
+    @Override
+    public StreamInfoItemCollector getStreams() throws ParsingException, ReCaptchaException, IOException {
+        StreamInfoItemCollector collector = getStreamPreviewInfoCollector();
+        Downloader dl = NewPipe.getDownloader();
+
+        String apiUrl = "https://api-v2.soundcloud.com/playlists/" + playlistId
+                + "?client_id=" + SoundcloudParsingHelper.clientId();
+
+        String response = dl.download(apiUrl);
+        JSONObject responseObject = new JSONObject(response);
+        JSONArray responseCollection = responseObject.getJSONArray("collection");
+
+        for (int i = 0; i < responseCollection.length(); i++) {
+            JSONObject track = responseCollection.getJSONObject(i);
+            try {
+                collector.commit(new SoundcloudStreamInfoItemExtractor(track));
+            } catch (Exception e) {
+                nextTracks.add(track.getString("id"));
+            }
+        }
+        return collector;
+    }
+
+    @Override
+    public StreamInfoItemCollector getNextStreams() throws ReCaptchaException, IOException, ParsingException {
+        if (nextTracks.equals(null)) {
+            return null;
+        }
+
+        StreamInfoItemCollector collector = getStreamPreviewInfoCollector();
+        Downloader dl = NewPipe.getDownloader();
+
+        // TODO: Do this per 10 tracks, instead of all tracks at once
+        String apiUrl = "https://api-v2.soundcloud.com/tracks?ids=";
+        for (String id : nextTracks) {
+            apiUrl += id;
+            if (!id.equals(nextTracks.get(nextTracks.size() - 1))) {
+                apiUrl += ",";
+            }
+        }
+        apiUrl += "&client_id=" + SoundcloudParsingHelper.clientId();
+
+        String response = dl.download(apiUrl);
+        JSONObject responseObject = new JSONObject(response);
+        JSONArray responseCollection = responseObject.getJSONArray("collection");
+
+        for (int i = 0; i < responseCollection.length(); i++) {
+            JSONObject track = responseCollection.getJSONObject(i);
+            collector.commit(new SoundcloudStreamInfoItemExtractor(track));
+        }
+        nextTracks = null;
+        return collector;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudPlaylistUrlIdHandler.java

@@ -0,0 +1,75 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import org.json.JSONObject;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.utils.Parser;
+
+public class SoundcloudPlaylistUrlIdHandler implements UrlIdHandler {
+
+    private static final SoundcloudPlaylistUrlIdHandler instance = new SoundcloudPlaylistUrlIdHandler();
+
+    public static SoundcloudPlaylistUrlIdHandler getInstance() {
+        return instance;
+    }
+
+    @Override
+    public String getUrl(String listId) throws ParsingException {
+        try {
+            Downloader dl = NewPipe.getDownloader();
+
+            String response = dl.download("https://api-v2.soundcloud.com/playlists/" + listId
+                    + "?client_id=" + SoundcloudParsingHelper.clientId());
+            JSONObject responseObject = new JSONObject(response);
+
+            return responseObject.getString("permalink_url");
+        } catch (Exception e) {
+            throw new ParsingException(e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public String getId(String url) throws ParsingException {
+        try {
+            Downloader dl = NewPipe.getDownloader();
+
+            String response = dl.download(url);
+            Document doc = Jsoup.parse(response);
+
+            Element androidElement = doc.select("meta[property=al:android:url]").first();
+            String id = androidElement.attr("content").substring(23);
+
+            return id;
+        } catch (Exception e) {
+            throw new ParsingException(e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public String cleanUrl(String complexUrl) throws ParsingException {
+        try {
+            Downloader dl = NewPipe.getDownloader();
+
+            String response = dl.download(complexUrl);
+            Document doc = Jsoup.parse(response);
+
+            Element ogElement = doc.select("meta[property=og:url]").first();
+            String url = ogElement.attr("content");
+
+            return url;
+        } catch (Exception e) {
+            throw new ParsingException(e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public boolean acceptUrl(String videoUrl) {
+        String regex = "^https?://(www\\.)?soundcloud.com/[0-9a-z_-]+/sets/[0-9a-z_-]+/?([#?].*)?$";
+        return Parser.isMatch(regex, videoUrl.toLowerCase());
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudSearchEngine.java

@@ -0,0 +1,61 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import java.io.IOException;
+import java.net.URLEncoder;
+import java.util.EnumSet;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.search.InfoItemSearchCollector;
+import org.schabi.newpipe.extractor.search.SearchEngine;
+
+public class SoundcloudSearchEngine extends SearchEngine {
+    public static final String CHARSET_UTF_8 = "UTF-8";
+
+    public SoundcloudSearchEngine(int serviceId) {
+        super(serviceId);
+    }
+
+    @Override
+    public InfoItemSearchCollector search(String query, int page, String languageCode, EnumSet<Filter> filter) throws IOException, ExtractionException {
+        InfoItemSearchCollector collector = getInfoItemSearchCollector();
+
+        Downloader downloader = NewPipe.getDownloader();
+
+        String url = "https://api-v2.soundcloud.com/search";
+
+        if (filter.contains(Filter.STREAM) && !filter.contains(Filter.CHANNEL)) {
+            url += "/tracks";
+        } else if (!filter.contains(Filter.STREAM) && filter.contains(Filter.CHANNEL)) {
+            url += "/users";
+        }
+
+        url += "?q=" + URLEncoder.encode(query, CHARSET_UTF_8)
+                + "&client_id=" + SoundcloudParsingHelper.clientId()
+                + "&limit=10"
+                + "&offset=" + Integer.toString(page * 10);
+
+        String searchJson = downloader.download(url);
+        JSONObject search = new JSONObject(searchJson);
+        JSONArray searchCollection = search.getJSONArray("collection");
+
+        if (searchCollection.length() == 0) {
+            throw new NothingFoundException("Nothing found");
+        }
+
+        for (int i = 0; i < searchCollection.length(); i++) {
+            JSONObject searchResult = searchCollection.getJSONObject(i);
+            String kind = searchResult.getString("kind");
+            if (kind.equals("user")) {
+                collector.commit(new SoundcloudChannelInfoItemExtractor(searchResult));
+            } else if (kind.equals("track")) {
+                collector.commit(new SoundcloudStreamInfoItemExtractor(searchResult));
+            }
+        }
+
+        return collector;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudService.java

@@ -0,0 +1,73 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import org.schabi.newpipe.extractor.StreamingService;
+import org.schabi.newpipe.extractor.SuggestionExtractor;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.channel.ChannelExtractor;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.playlist.PlaylistExtractor;
+import org.schabi.newpipe.extractor.search.SearchEngine;
+import org.schabi.newpipe.extractor.stream.StreamExtractor;
+
+import java.io.IOException;
+
+public class SoundcloudService extends StreamingService {
+
+    public SoundcloudService(int id) {
+        super(id);
+    }
+
+    @Override
+    public ServiceInfo getServiceInfo() {
+        ServiceInfo serviceInfo = new ServiceInfo();
+        serviceInfo.name = "Soundcloud";
+        return serviceInfo;
+    }
+
+    @Override
+    public StreamExtractor getStreamExtractorInstance(String url)
+            throws ExtractionException, IOException {
+        UrlIdHandler urlIdHandler = SoundcloudStreamUrlIdHandler.getInstance();
+        if (urlIdHandler.acceptUrl(url)) {
+            return new SoundcloudStreamExtractor(urlIdHandler, url, getServiceId());
+        } else {
+            throw new IllegalArgumentException("supplied String is not a valid Soundcloud URL");
+        }
+    }
+
+    @Override
+    public SearchEngine getSearchEngineInstance() {
+        return new SoundcloudSearchEngine(getServiceId());
+    }
+
+    @Override
+    public UrlIdHandler getStreamUrlIdHandlerInstance() {
+        return SoundcloudStreamUrlIdHandler.getInstance();
+    }
+
+    @Override
+    public UrlIdHandler getChannelUrlIdHandlerInstance() {
+        return SoundcloudChannelUrlIdHandler.getInstance();
+    }
+
+
+    @Override
+    public UrlIdHandler getPlaylistUrlIdHandlerInstance() {
+        return SoundcloudPlaylistUrlIdHandler.getInstance();
+    }
+
+    @Override
+    public ChannelExtractor getChannelExtractorInstance(String url) throws ExtractionException, IOException {
+        return new SoundcloudChannelExtractor(getChannelUrlIdHandlerInstance(), url, getServiceId());
+    }
+
+    @Override
+    public PlaylistExtractor getPlaylistExtractorInstance(String url) throws ExtractionException, IOException {
+        return new SoundcloudPlaylistExtractor(getPlaylistUrlIdHandlerInstance(), url, getServiceId());
+    }
+
+    @Override
+    public SuggestionExtractor getSuggestionExtractorInstance() {
+        return new SoundcloudSuggestionExtractor(getServiceId());
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudStreamExtractor.java

@@ -0,0 +1,230 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Vector;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.MediaFormat;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+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.stream.AudioStream;
+import org.schabi.newpipe.extractor.stream.StreamExtractor;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemCollector;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemExtractor;
+import org.schabi.newpipe.extractor.stream.StreamType;
+import org.schabi.newpipe.extractor.stream.VideoStream;
+import org.schabi.newpipe.extractor.utils.Parser;
+import org.schabi.newpipe.extractor.utils.Parser.RegexException;
+
+public class SoundcloudStreamExtractor extends StreamExtractor {
+    private String pageUrl;
+    private String trackId;
+    private JSONObject track;
+
+    public SoundcloudStreamExtractor(UrlIdHandler urlIdHandler, String pageUrl, int serviceId) throws ExtractionException, IOException {
+        super(urlIdHandler, pageUrl, serviceId);
+
+        Downloader dl = NewPipe.getDownloader();
+
+        trackId = urlIdHandler.getId(pageUrl);
+        String apiUrl = "https://api-v2.soundcloud.com/tracks/" + trackId
+                + "?client_id=" + SoundcloudParsingHelper.clientId();
+
+        String response = dl.download(apiUrl);
+        track = new JSONObject(response);
+
+        if (!track.getString("policy").equals("ALLOW") && !track.getString("policy").equals("MONETIZE")) {
+            throw new ContentNotAvailableException("Content not available: policy " + track.getString("policy"));
+        }
+    }
+
+    @Override
+    public String getId() {
+        return trackId;
+    }
+
+    @Override
+    public String getTitle() {
+        return track.getString("title");
+    }
+
+    @Override
+    public String getDescription() {
+        return track.getString("description");
+    }
+
+    @Override
+    public String getUploader() {
+        return track.getJSONObject("user").getString("username");
+    }
+
+    @Override
+    public int getLength() {
+        return track.getInt("duration") / 1000;
+    }
+
+    @Override
+    public long getViewCount() {
+        return track.getLong("playback_count");
+    }
+
+    @Override
+    public String getUploadDate() throws ParsingException {
+        return SoundcloudParsingHelper.toDateString(track.getString("created_at"));
+    }
+
+    @Override
+    public String getThumbnailUrl() {
+        return track.getString("artwork_url");
+    }
+
+    @Override
+    public String getUploaderThumbnailUrl() {
+        return track.getJSONObject("user").getString("avatar_url");
+    }
+
+    @Override
+    public String getDashMpdUrl() {
+        return null;
+    }
+
+    @Override
+    public List<AudioStream> getAudioStreams() throws ReCaptchaException, IOException, RegexException {
+        Vector<AudioStream> audioStreams = new Vector<>();
+        Downloader dl = NewPipe.getDownloader();
+
+        String apiUrl = "https://api.soundcloud.com/i1/tracks/" + trackId + "/streams"
+                + "?client_id=" + SoundcloudParsingHelper.clientId();
+
+        String response = dl.download(apiUrl);
+        JSONObject responseObject = new JSONObject(response);
+
+        AudioStream audioStream = new AudioStream(responseObject.getString("http_mp3_128_url"), MediaFormat.MP3.id, 128);
+        audioStreams.add(audioStream);
+
+        return audioStreams;
+    }
+
+    @Override
+    public List<VideoStream> getVideoStreams() {
+        return null;
+    }
+
+    @Override
+    public List<VideoStream> getVideoOnlyStreams() {
+       return null;
+    }
+
+    @Override
+    public int getTimeStamp() throws ParsingException {
+        String timeStamp;
+        try {
+            timeStamp = Parser.matchGroup1("(#t=\\d{0,3}h?\\d{0,3}m?\\d{1,3}s?)", pageUrl);
+        } catch (Parser.RegexException e) {
+            // catch this instantly since an url does not necessarily have to have a time stamp
+
+            // -2 because well the testing system will then know its the regex that failed :/
+            // not good i know
+            return -2;
+        }
+
+        if (!timeStamp.isEmpty()) {
+            try {
+                String secondsString = "";
+                String minutesString = "";
+                String hoursString = "";
+                try {
+                    secondsString = Parser.matchGroup1("(\\d{1,3})s", timeStamp);
+                    minutesString = Parser.matchGroup1("(\\d{1,3})m", timeStamp);
+                    hoursString = Parser.matchGroup1("(\\d{1,3})h", timeStamp);
+                } catch (Exception e) {
+                    //it could be that time is given in another method
+                    if (secondsString.isEmpty() //if nothing was got,
+                            && minutesString.isEmpty()//treat as unlabelled seconds
+                            && hoursString.isEmpty()) {
+                        secondsString = Parser.matchGroup1("t=(\\d+)", timeStamp);
+                    }
+                }
+
+                int seconds = secondsString.isEmpty() ? 0 : Integer.parseInt(secondsString);
+                int minutes = minutesString.isEmpty() ? 0 : Integer.parseInt(minutesString);
+                int hours = hoursString.isEmpty() ? 0 : Integer.parseInt(hoursString);
+
+                //don't trust BODMAS!
+                return seconds + (60 * minutes) + (3600 * hours);
+                //Log.d(TAG, "derived timestamp value:"+ret);
+                //the ordering varies internationally
+            } catch (ParsingException e) {
+                throw new ParsingException("Could not get timestamp.", e);
+            }
+        } else {
+            return 0;
+        }
+    }
+
+    @Override
+    public int getAgeLimit() {
+        return 0;
+    }
+
+    @Override
+    public String getAverageRating() {
+        return null;
+    }
+
+    @Override
+    public int getLikeCount() {
+        return track.getInt("likes_count");
+    }
+
+    @Override
+    public int getDislikeCount() {
+        return 0;
+    }
+
+    @Override
+    public StreamInfoItemExtractor getNextVideo() {
+        return null;
+    }
+
+    @Override
+    public StreamInfoItemCollector getRelatedVideos() throws ReCaptchaException, IOException, ParsingException {
+        StreamInfoItemCollector collector = getStreamPreviewInfoCollector();
+        Downloader dl = NewPipe.getDownloader();
+
+        String apiUrl = "https://api-v2.soundcloud.com/tracks/" + trackId + "/related"
+                + "?client_id=" + SoundcloudParsingHelper.clientId();
+
+        String response = dl.download(apiUrl);
+        JSONObject responseObject = new JSONObject(response);
+        JSONArray responseCollection = responseObject.getJSONArray("collection");
+
+        for (int i = 0; i < responseCollection.length(); i++) {
+            JSONObject relatedVideo = responseCollection.getJSONObject(i);
+            collector.commit(new SoundcloudStreamInfoItemExtractor(relatedVideo));
+        }
+        return collector;
+    }
+
+    @Override
+    public String getChannelUrl() {
+        return track.getJSONObject("user").getString("permalink_url");
+    }
+
+    @Override
+    public StreamType getStreamType() {
+        return StreamType.AUDIO_STREAM;
+    }
+
+    @Override
+    public String getErrorMessage() {
+        return null;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudStreamInfoItemExtractor.java

@@ -0,0 +1,60 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import org.json.JSONObject;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemExtractor;
+import org.schabi.newpipe.extractor.stream.StreamType;
+
+public class SoundcloudStreamInfoItemExtractor implements StreamInfoItemExtractor {
+
+    private final JSONObject searchResult;
+
+    public SoundcloudStreamInfoItemExtractor(JSONObject searchResult) {
+        this.searchResult = searchResult;
+    }
+
+    @Override
+    public String getWebPageUrl() {
+        return searchResult.getString("permalink_url");
+    }
+
+    @Override
+    public String getTitle() {
+        return searchResult.getString("title");
+    }
+
+    @Override
+    public int getDuration() {
+        return searchResult.getInt("duration") / 1000;
+    }
+
+    @Override
+    public String getUploader() {
+        return searchResult.getJSONObject("user").getString("username");
+    }
+
+    @Override
+    public String getUploadDate() throws ParsingException {
+        return SoundcloudParsingHelper.toTimeAgoString(searchResult.getString("created_at"));
+    }
+
+    @Override
+    public long getViewCount() {
+        return searchResult.getLong("playback_count");
+    }
+
+    @Override
+    public String getThumbnailUrl() {
+        return searchResult.getString("artwork_url");
+    }
+
+    @Override
+    public StreamType getStreamType() {
+        return StreamType.AUDIO_STREAM;
+    }
+
+    @Override
+    public boolean isAd() {
+        return false;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudStreamUrlIdHandler.java

@@ -0,0 +1,77 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import org.json.JSONObject;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.utils.Parser;
+
+public class SoundcloudStreamUrlIdHandler implements UrlIdHandler {
+
+    private static final SoundcloudStreamUrlIdHandler instance = new SoundcloudStreamUrlIdHandler();
+    private SoundcloudStreamUrlIdHandler() {
+    }
+
+    public static SoundcloudStreamUrlIdHandler getInstance() {
+        return instance;
+    }
+
+    @Override
+    public String getUrl(String videoId) throws ParsingException {
+        try {
+            Downloader dl = NewPipe.getDownloader();
+
+            String response = dl.download("https://api-v2.soundcloud.com/tracks/" + videoId
+                    + "?client_id=" + SoundcloudParsingHelper.clientId());
+            JSONObject responseObject = new JSONObject(response);
+
+            return responseObject.getString("permalink_url");
+        } catch (Exception e) {
+            throw new ParsingException(e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public String getId(String url) throws ParsingException {
+        try {
+            Downloader dl = NewPipe.getDownloader();
+
+            String response = dl.download(url);
+            Document doc = Jsoup.parse(response);
+
+            Element androidElement = doc.select("meta[property=al:android:url]").first();
+            String id = androidElement.attr("content").substring(20);
+
+            return id;
+        } catch (Exception e) {
+            throw new ParsingException(e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public String cleanUrl(String complexUrl) throws ParsingException {
+        try {
+            Downloader dl = NewPipe.getDownloader();
+
+            String response = dl.download(complexUrl);
+            Document doc = Jsoup.parse(response);
+
+            Element ogElement = doc.select("meta[property=og:url]").first();
+            String url = ogElement.attr("content");
+
+            return url;
+        } catch (Exception e) {
+            throw new ParsingException(e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public boolean acceptUrl(String videoUrl) {
+        String regex = "^https?://(www\\.)?soundcloud.com/[0-9a-z_-]+/(?!(tracks|albums|sets|reposts|followers|following)/?$)[0-9a-z_-]+/?([#?].*)?$";
+        return Parser.isMatch(regex, videoUrl.toLowerCase());
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/soundcloud/SoundcloudSuggestionExtractor.java

@@ -0,0 +1,46 @@
+package org.schabi.newpipe.extractor.services.soundcloud;
+
+import java.io.IOException;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.SuggestionExtractor;
+import org.schabi.newpipe.extractor.exceptions.ReCaptchaException;
+import org.schabi.newpipe.extractor.utils.Parser.RegexException;
+
+public class SoundcloudSuggestionExtractor extends SuggestionExtractor {
+
+    public static final String CHARSET_UTF_8 = "UTF-8";
+
+    public SoundcloudSuggestionExtractor(int serviceId) {
+        super(serviceId);
+    }
+
+    @Override
+    public List<String> suggestionList(String query, String contentCountry) throws RegexException, ReCaptchaException, IOException {
+        List<String> suggestions = new ArrayList<>();
+
+        Downloader dl = NewPipe.getDownloader();
+
+        String url = "https://api-v2.soundcloud.com/search/queries"
+                + "?q=" + URLEncoder.encode(query, CHARSET_UTF_8)
+                + "&client_id=" + SoundcloudParsingHelper.clientId()
+                + "&limit=10";
+
+        String response = dl.download(url);
+        JSONObject responseObject = new JSONObject(response);
+        JSONArray responseCollection = responseObject.getJSONArray("collection");
+
+        for (int i = 0; i < responseCollection.length(); i++) {
+            JSONObject suggestion = responseCollection.getJSONObject(i);
+            suggestions.add(suggestion.getString("query"));
+        }
+
+        return suggestions;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/ItagItem.java

@@ -0,0 +1,160 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.schabi.newpipe.extractor.MediaFormat;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+
+import static org.schabi.newpipe.extractor.MediaFormat.M4A;
+import static org.schabi.newpipe.extractor.MediaFormat.MPEG_4;
+import static org.schabi.newpipe.extractor.MediaFormat.WEBM;
+import static org.schabi.newpipe.extractor.MediaFormat.WEBMA;
+import static org.schabi.newpipe.extractor.MediaFormat.v3GPP;
+import static org.schabi.newpipe.extractor.services.youtube.ItagItem.ItagType.AUDIO;
+import static org.schabi.newpipe.extractor.services.youtube.ItagItem.ItagType.VIDEO;
+import static org.schabi.newpipe.extractor.services.youtube.ItagItem.ItagType.VIDEO_ONLY;
+
+public class ItagItem {
+    /**
+     * List can be found here https://github.com/rg3/youtube-dl/blob/master/youtube_dl/extractor/youtube.py#L360
+     */
+    private static final ItagItem[] ITAG_LIST = {
+            /////////////////////////////////////////////////////
+            // VIDEO     ID  Type   Format  Resolution  FPS  ///
+            ///////////////////////////////////////////////////
+            new ItagItem(17, VIDEO, v3GPP, "144p"),
+            new ItagItem(36, VIDEO, v3GPP, "240p"),
+
+            new ItagItem(18, VIDEO, MPEG_4, "360p"),
+            new ItagItem(34, VIDEO, MPEG_4, "360p"),
+            new ItagItem(35, VIDEO, MPEG_4, "480p"),
+            new ItagItem(59, VIDEO, MPEG_4, "480p"),
+            new ItagItem(78, VIDEO, MPEG_4, "480p"),
+            new ItagItem(22, VIDEO, MPEG_4, "720p"),
+            new ItagItem(37, VIDEO, MPEG_4, "1080p"),
+            new ItagItem(38, VIDEO, MPEG_4, "1080p"),
+
+            new ItagItem(43, VIDEO, WEBM, "360p"),
+            new ItagItem(44, VIDEO, WEBM, "480p"),
+            new ItagItem(45, VIDEO, WEBM, "720p"),
+            new ItagItem(46, VIDEO, WEBM, "1080p"),
+
+            ////////////////////////////////////////////////////////////////////
+            // AUDIO     ID      ItagType          Format        Bitrate    ///
+            //////////////////////////////////////////////////////////////////
+            // Disable Opus codec as it's not well supported in older devices
+//          new ItagItem(249, AUDIO, WEBMA, 50),
+//          new ItagItem(250, AUDIO, WEBMA, 70),
+//          new ItagItem(251, AUDIO, WEBMA, 16),
+            new ItagItem(171, AUDIO, WEBMA, 128),
+            new ItagItem(172, AUDIO, WEBMA, 256),
+            new ItagItem(139, AUDIO, M4A, 48),
+            new ItagItem(140, AUDIO, M4A, 128),
+            new ItagItem(141, AUDIO, M4A, 256),
+
+            /// VIDEO ONLY ////////////////////////////////////////////
+            //           ID      Type     Format  Resolution  FPS  ///
+            /////////////////////////////////////////////////////////
+            // Don't add VideoOnly streams that have normal variants
+            new ItagItem(160, VIDEO_ONLY, MPEG_4, "144p"),
+            new ItagItem(133, VIDEO_ONLY, MPEG_4, "240p"),
+//          new ItagItem(134, VIDEO_ONLY, MPEG_4, "360p"),
+            new ItagItem(135, VIDEO_ONLY, MPEG_4, "480p"),
+            new ItagItem(212, VIDEO_ONLY, MPEG_4, "480p"),
+//          new ItagItem(136, VIDEO_ONLY, MPEG_4, "720p"),
+            new ItagItem(298, VIDEO_ONLY, MPEG_4, "720p60", 60),
+            new ItagItem(137, VIDEO_ONLY, MPEG_4, "1080p"),
+            new ItagItem(299, VIDEO_ONLY, MPEG_4, "1080p60", 60),
+            new ItagItem(266, VIDEO_ONLY, MPEG_4, "2160p"),
+
+            new ItagItem(278, VIDEO_ONLY, WEBM, "144p"),
+            new ItagItem(242, VIDEO_ONLY, WEBM, "240p"),
+//          new ItagItem(243, VIDEO_ONLY, WEBM, "360p"),
+            new ItagItem(244, VIDEO_ONLY, WEBM, "480p"),
+            new ItagItem(245, VIDEO_ONLY, WEBM, "480p"),
+            new ItagItem(246, VIDEO_ONLY, WEBM, "480p"),
+            new ItagItem(247, VIDEO_ONLY, WEBM, "720p"),
+            new ItagItem(248, VIDEO_ONLY, WEBM, "1080p"),
+            new ItagItem(271, VIDEO_ONLY, WEBM, "1440p"),
+            // #272 is either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
+            new ItagItem(272, VIDEO_ONLY, WEBM, "2160p"),
+            new ItagItem(302, VIDEO_ONLY, WEBM, "720p60", 60),
+            new ItagItem(303, VIDEO_ONLY, WEBM, "1080p60", 60),
+            new ItagItem(308, VIDEO_ONLY, WEBM, "1440p60", 60),
+            new ItagItem(313, VIDEO_ONLY, WEBM, "2160p"),
+            new ItagItem(315, VIDEO_ONLY, WEBM, "2160p60", 60)
+    };
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Utils
+    //////////////////////////////////////////////////////////////////////////*/
+
+    public static boolean isSupported(int itag) {
+        for (ItagItem item : ITAG_LIST) {
+            if (itag == item.id) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static ItagItem getItag(int itagId) throws ParsingException {
+        for (ItagItem item : ITAG_LIST) {
+            if (itagId == item.id) {
+                return item;
+            }
+        }
+        throw new ParsingException("itag=" + Integer.toString(itagId) + " not supported");
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Contructors and misc
+    //////////////////////////////////////////////////////////////////////////*/
+
+    public enum ItagType {
+        AUDIO,
+        VIDEO,
+        VIDEO_ONLY
+    }
+
+    /**
+     * Call {@link #ItagItem(int, ItagType, MediaFormat, String, int)} with the fps set to 30.
+     */
+    public ItagItem(int id, ItagType type, MediaFormat format, String resolution) {
+        this.id = id;
+        this.itagType = type;
+        this.mediaFormatId = format.id;
+        this.resolutionString = resolution;
+        this.fps = 30;
+    }
+
+    /**
+     * Constructor for videos.
+     *
+     * @param resolution string that will be used in the frontend
+     */
+    public ItagItem(int id, ItagType type, MediaFormat format, String resolution, int fps) {
+        this.id = id;
+        this.itagType = type;
+        this.mediaFormatId = format.id;
+        this.resolutionString = resolution;
+        this.fps = fps;
+    }
+
+    public ItagItem(int id, ItagType type, MediaFormat format, int avgBitrate) {
+        this.id = id;
+        this.itagType = type;
+        this.mediaFormatId = format.id;
+        this.avgBitrate = avgBitrate;
+    }
+
+    public int id;
+    public ItagType itagType;
+    public int mediaFormatId;
+
+    // Audio fields
+    public int avgBitrate = -1;
+
+    // Video fields
+    public String resolutionString;
+    public int fps = -1;
+
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeChannelExtractor.java

@@ -0,0 +1,355 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.channel.ChannelExtractor;
+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.stream.StreamInfoItemCollector;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemExtractor;
+import org.schabi.newpipe.extractor.stream.StreamType;
+import org.schabi.newpipe.extractor.utils.Parser;
+import org.schabi.newpipe.extractor.utils.Utils;
+
+import java.io.IOException;
+
+/*
+ * Created by Christian Schabesberger on 25.07.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * YoutubeChannelExtractor.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+@SuppressWarnings("WeakerAccess")
+public class YoutubeChannelExtractor extends ChannelExtractor {
+    private static final String CHANNEL_FEED_BASE = "https://www.youtube.com/feeds/videos.xml?channel_id=";
+
+    private Document doc;
+    /**
+     * It's lazily initialized (when getNextStreams is called)
+     */
+    private Document nextStreamsAjax;
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Variables for cache purposes (not "select" the current document all over again)
+    //////////////////////////////////////////////////////////////////////////*/
+    private String channelId;
+    private String channelName;
+    private String avatarUrl;
+    private String bannerUrl;
+    private String feedUrl;
+    private long subscriberCount = -1;
+
+    public YoutubeChannelExtractor(UrlIdHandler urlIdHandler, String url, int serviceId) throws ExtractionException, IOException {
+        super(urlIdHandler, urlIdHandler.cleanUrl(url), serviceId);
+        fetchDocument();
+    }
+
+    @Override
+    public String getChannelId() throws ParsingException {
+        try {
+            if (channelId == null) {
+                channelId = getUrlIdHandler().getId(getUrl());
+            }
+
+            return channelId;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get channel id");
+        }
+    }
+
+    @Override
+    public String getChannelName() throws ParsingException {
+        try {
+            if (channelName == null) {
+                channelName = doc.select("span[class=\"qualified-channel-title-text\"]").first().select("a").first().text();
+            }
+
+            return channelName;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get channel name");
+        }
+    }
+
+    @Override
+    public String getAvatarUrl() throws ParsingException {
+        try {
+            if (avatarUrl == null) {
+                avatarUrl = doc.select("img[class=\"channel-header-profile-image\"]").first().attr("abs:src");
+            }
+
+            return avatarUrl;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get avatar", e);
+        }
+    }
+
+    @Override
+    public String getBannerUrl() throws ParsingException {
+        try {
+            if (bannerUrl == null) {
+                Element el = doc.select("div[id=\"gh-banner\"]").first().select("style").first();
+                String cssContent = el.html();
+                String url = "https:" + Parser.matchGroup1("url\\(([^)]+)\\)", cssContent);
+
+                bannerUrl = url.contains("s.ytimg.com") || url.contains("default_banner") ? null : url;
+            }
+
+            return bannerUrl;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get Banner", e);
+        }
+    }
+
+    @Override
+    public StreamInfoItemCollector getStreams() throws ParsingException {
+        StreamInfoItemCollector collector = getStreamPreviewInfoCollector();
+        Element ul = doc.select("ul[id=\"browse-items-primary\"]").first();
+        collectStreamsFrom(collector, ul);
+        return collector;
+    }
+
+    @Override
+    public long getSubscriberCount() throws ParsingException {
+
+        if (subscriberCount == -1) {
+            Element el = doc.select("span[class*=\"yt-subscription-button-subscriber-count\"]").first();
+            if (el != null) {
+                subscriberCount = Long.parseLong(Utils.removeNonDigitCharacters(el.text()));
+            } else {
+                throw new ParsingException("Could not get subscriber count");
+            }
+        }
+
+        return subscriberCount;
+    }
+
+    @Override
+    public String getFeedUrl() throws ParsingException {
+        try {
+            if (feedUrl == null) {
+                String channelId = doc.getElementsByClass("yt-uix-subscription-button").first().attr("data-channel-external-id");
+                feedUrl = channelId == null ? "" : CHANNEL_FEED_BASE + channelId;
+            }
+
+            return feedUrl;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get feed url", e);
+        }
+    }
+
+    @Override
+    public StreamInfoItemCollector getNextStreams() throws ExtractionException, IOException {
+        if (!hasMoreStreams()) {
+            throw new ExtractionException("Channel doesn't have more streams");
+        }
+
+        StreamInfoItemCollector collector = new StreamInfoItemCollector(getServiceId());
+        setupNextStreamsAjax(NewPipe.getDownloader());
+        collectStreamsFrom(collector, nextStreamsAjax.select("body").first());
+
+        return collector;
+    }
+
+    private void setupNextStreamsAjax(Downloader downloader) throws IOException, ReCaptchaException, ParsingException {
+        String ajaxDataRaw = downloader.download(nextStreamsUrl);
+        try {
+            JSONObject ajaxData = new JSONObject(ajaxDataRaw);
+
+            String htmlDataRaw = ajaxData.getString("content_html");
+            nextStreamsAjax = Jsoup.parse(htmlDataRaw, nextStreamsUrl);
+
+            String nextStreamsHtmlDataRaw = ajaxData.getString("load_more_widget_html");
+            if (!nextStreamsHtmlDataRaw.isEmpty()) {
+                Document nextStreamsData = Jsoup.parse(nextStreamsHtmlDataRaw, nextStreamsUrl);
+                nextStreamsUrl = getNextStreamsUrl(nextStreamsData);
+            } else {
+                nextStreamsUrl = "";
+            }
+        } catch (JSONException e) {
+            throw new ParsingException("Could not parse json data for next streams", e);
+        }
+    }
+
+    private String getNextStreamsUrl(Document d) throws ParsingException {
+        try {
+            Element button = d.select("button[class*=\"yt-uix-load-more\"]").first();
+            if (button != null) {
+                return button.attr("abs:data-uix-load-more-href");
+            } else {
+                // Sometimes channels are simply so small, they don't have a more streams/videos
+                return "";
+            }
+        } catch (Exception e) {
+            throw new ParsingException("could not get next streams' url", e);
+        }
+    }
+
+    private void fetchDocument() throws IOException, ReCaptchaException, ParsingException {
+        Downloader downloader = NewPipe.getDownloader();
+
+        String userUrl = getUrl() + "/videos?view=0&flow=list&sort=dd&live_view=10000";
+        String pageContent = downloader.download(userUrl);
+        doc = Jsoup.parse(pageContent, userUrl);
+
+        nextStreamsUrl = getNextStreamsUrl(doc);
+        nextStreamsAjax = null;
+    }
+
+    private void collectStreamsFrom(StreamInfoItemCollector collector, Element element) throws ParsingException {
+        collector.getItemList().clear();
+
+        for (final Element li : element.children()) {
+            if (li.select("div[class=\"feed-item-dismissable\"]").first() != null) {
+                collector.commit(new StreamInfoItemExtractor() {
+                    @Override
+                    public StreamType getStreamType() throws ParsingException {
+                        return StreamType.VIDEO_STREAM;
+                    }
+
+                    @Override
+                    public boolean isAd() throws ParsingException {
+                        return !li.select("span[class*=\"icon-not-available\"]").isEmpty();
+                    }
+
+                    @Override
+                    public String getWebPageUrl() throws ParsingException {
+                        try {
+                            Element el = li.select("div[class=\"feed-item-dismissable\"]").first();
+                            Element dl = el.select("h3").first().select("a").first();
+                            return dl.attr("abs:href");
+                        } catch (Exception e) {
+                            throw new ParsingException("Could not get web page url for the video", e);
+                        }
+                    }
+
+                    @Override
+                    public String getTitle() throws ParsingException {
+                        try {
+                            Element el = li.select("div[class=\"feed-item-dismissable\"]").first();
+                            Element dl = el.select("h3").first().select("a").first();
+                            return dl.text();
+                        } catch (Exception e) {
+                            throw new ParsingException("Could not get title", e);
+                        }
+                    }
+
+                    @Override
+                    public int getDuration() throws ParsingException {
+                        try {
+                            return YoutubeParsingHelper.parseDurationString(
+                                    li.select("span[class=\"video-time\"]").first().text());
+                        } catch (Exception e) {
+                            if (isLiveStream(li)) {
+                                // -1 for no duration
+                                return -1;
+                            } else {
+                                throw new ParsingException("Could not get Duration: " + getTitle(), e);
+                            }
+                        }
+                    }
+
+                    @Override
+                    public String getUploader() throws ParsingException {
+                        return getChannelName();
+                    }
+
+                    @Override
+                    public String getUploadDate() throws ParsingException {
+                        try {
+                            Element meta = li.select("div[class=\"yt-lockup-meta\"]").first();
+                            Element li = meta.select("li").first();
+                            if (li == null) {
+                                //this means we have a youtube red video
+                                return "";
+                            } else {
+                                return li.text();
+                            }
+                        } catch (Exception e) {
+                            throw new ParsingException("Could not get upload date", e);
+                        }
+                    }
+
+                    @Override
+                    public long getViewCount() throws ParsingException {
+                        String output;
+                        String input;
+                        try {
+                            input = li.select("div[class=\"yt-lockup-meta\"]").first()
+                                    .select("li").get(1)
+                                    .text();
+                        } catch (IndexOutOfBoundsException e) {
+                            return -1;
+                        }
+
+                        output = Utils.removeNonDigitCharacters(input);
+
+                        try {
+                            return Long.parseLong(output);
+                        } catch (NumberFormatException e) {
+                            // if this happens the video probably has no views
+                            if (!input.isEmpty()) {
+                                return 0;
+                            } else {
+                                throw new ParsingException("Could not handle input: " + input, e);
+                            }
+                        }
+                    }
+
+                    @Override
+                    public String getThumbnailUrl() throws ParsingException {
+                        try {
+                            String url;
+                            Element te = li.select("span[class=\"yt-thumb-clip\"]").first()
+                                    .select("img").first();
+                            url = te.attr("abs:src");
+                            // Sometimes youtube sends links to gif files which somehow seem to not exist
+                            // anymore. Items with such gif also offer a secondary image source. So we are going
+                            // to use that if we've caught such an item.
+                            if (url.contains(".gif")) {
+                                url = te.attr("abs:data-thumb");
+                            }
+                            return url;
+                        } catch (Exception e) {
+                            throw new ParsingException("Could not get thumbnail url", e);
+                        }
+                    }
+
+                    private boolean isLiveStream(Element item) {
+                        Element bla = item.select("span[class*=\"yt-badge-live\"]").first();
+
+                        if (bla == null) {
+                            // sometimes livestreams dont have badges but sill are live streams
+                            // if video time is not available we most likly have an offline livestream
+                            if (item.select("span[class*=\"video-time\"]").first() == null) {
+                                return true;
+                            }
+                        }
+                        return bla != null;
+                    }
+                });
+            }
+        }
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeChannelInfoItemExtractor.java

@@ -0,0 +1,89 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.jsoup.nodes.Element;
+import org.schabi.newpipe.extractor.channel.ChannelInfoItemExtractor;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.utils.Utils;
+
+/*
+ * Created by Christian Schabesberger on 12.02.17.
+ *
+ * Copyright (C) Christian Schabesberger 2017 <chris.schabesberger@mailbox.org>
+ * YoutubeChannelInfoItemExtractor.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class YoutubeChannelInfoItemExtractor implements ChannelInfoItemExtractor {
+    private Element el;
+
+    public YoutubeChannelInfoItemExtractor(Element el) {
+        this.el = el;
+    }
+
+    @Override
+    public String getThumbnailUrl() throws ParsingException {
+        Element img = el.select("span[class*=\"yt-thumb-simple\"]").first()
+                .select("img").first();
+
+        String url = img.attr("abs:src");
+
+        if (url.contains("gif")) {
+            url = img.attr("abs:data-thumb");
+        }
+        return url;
+    }
+
+    @Override
+    public String getChannelName() throws ParsingException {
+        return el.select("a[class*=\"yt-uix-tile-link\"]").first()
+                .text();
+    }
+
+    @Override
+    public String getWebPageUrl() throws ParsingException {
+        return el.select("a[class*=\"yt-uix-tile-link\"]").first()
+                .attr("abs:href");
+    }
+
+    @Override
+    public long getSubscriberCount() throws ParsingException {
+        Element subsEl = el.select("span[class*=\"yt-subscriber-count\"]").first();
+        if (subsEl == null) {
+            return 0;
+        } else {
+            return Long.parseLong(Utils.removeNonDigitCharacters(subsEl.text()));
+        }
+    }
+
+    @Override
+    public long getViewCount() throws ParsingException {
+        Element metaEl = el.select("ul[class*=\"yt-lockup-meta-info\"]").first();
+        if (metaEl == null) {
+            return 0;
+        } else {
+            return Long.parseLong(Utils.removeNonDigitCharacters(metaEl.text()));
+        }
+    }
+
+    @Override
+    public String getDescription() throws ParsingException {
+        Element desEl = el.select("div[class*=\"yt-lockup-description\"]").first();
+        if (desEl == null) {
+            return "";
+        } else {
+            return desEl.text();
+        }
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeChannelUrlIdHandler.java

@@ -0,0 +1,58 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.utils.Parser;
+
+/*
+ * Created by Christian Schabesberger on 25.07.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * YoutubeChannelUrlIdHandler.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class YoutubeChannelUrlIdHandler implements UrlIdHandler {
+
+    private static final YoutubeChannelUrlIdHandler instance = new YoutubeChannelUrlIdHandler();
+    private static final String ID_PATTERN = "/(user/[A-Za-z0-9_-]*|channel/[A-Za-z0-9_-]*)";
+
+    public static YoutubeChannelUrlIdHandler getInstance() {
+        return instance;
+    }
+
+    @Override
+    public String getUrl(String channelId) {
+        return "https://www.youtube.com/" + channelId;
+    }
+
+    @Override
+    public String getId(String siteUrl) throws ParsingException {
+        return Parser.matchGroup1(ID_PATTERN, siteUrl);
+    }
+
+    @Override
+    public String cleanUrl(String siteUrl) throws ParsingException {
+        return getUrl(getId(siteUrl));
+    }
+
+    @Override
+    public boolean acceptUrl(String videoUrl) {
+        return (videoUrl.contains("youtube") ||
+                videoUrl.contains("youtu.be")) &&
+                (videoUrl.contains("/user/") ||
+                        videoUrl.contains("/channel/"));
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeParsingHelper.java

@@ -0,0 +1,66 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+
+/*
+ * Created by Christian Schabesberger on 02.03.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * YoutubeParsingHelper.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class YoutubeParsingHelper {
+
+    private YoutubeParsingHelper() {
+    }
+
+    public static int parseDurationString(String input)
+            throws ParsingException, NumberFormatException {
+        String[] splitInput = input.split(":");
+        String days = "0";
+        String hours = "0";
+        String minutes = "0";
+        String seconds;
+
+        switch (splitInput.length) {
+            case 4:
+                days = splitInput[0];
+                hours = splitInput[1];
+                minutes = splitInput[2];
+                seconds = splitInput[3];
+                break;
+            case 3:
+                hours = splitInput[0];
+                minutes = splitInput[1];
+                seconds = splitInput[2];
+                break;
+            case 2:
+                minutes = splitInput[0];
+                seconds = splitInput[1];
+                break;
+            case 1:
+                seconds = splitInput[0];
+                break;
+            default:
+                throw new ParsingException("Error duration string with unknown format: " + input);
+        }
+        return ((((Integer.parseInt(days) * 24)
+                + Integer.parseInt(hours) * 60)
+                + Integer.parseInt(minutes)) * 60)
+                + Integer.parseInt(seconds);
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubePlaylistExtractor.java

@@ -0,0 +1,329 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+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.playlist.PlaylistExtractor;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemCollector;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemExtractor;
+import org.schabi.newpipe.extractor.stream.StreamType;
+import org.schabi.newpipe.extractor.utils.Parser;
+import org.schabi.newpipe.extractor.utils.Utils;
+
+import java.io.IOException;
+
+@SuppressWarnings("WeakerAccess")
+public class YoutubePlaylistExtractor extends PlaylistExtractor {
+
+    private Document doc = null;
+    /**
+     * It's lazily initialized (when getNextStreams is called)
+     */
+    private Document nextStreamsAjax = null;
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Variables for cache purposes (not "select" the current document all over again)
+    //////////////////////////////////////////////////////////////////////////*/
+    private String playlistId;
+    private String playlistName;
+    private String avatarUrl;
+    private String bannerUrl;
+
+    private long streamsCount;
+
+    private String uploaderUrl;
+    private String uploaderName;
+    private String uploaderAvatarUrl;
+
+    public YoutubePlaylistExtractor(UrlIdHandler urlIdHandler, String url, int serviceId) throws IOException, ExtractionException {
+        super(urlIdHandler, urlIdHandler.cleanUrl(url), serviceId);
+        fetchDocument();
+    }
+
+    @Override
+    public String getPlaylistId() throws ParsingException {
+        try {
+            if (playlistId == null) {
+                playlistId = getUrlIdHandler().getId(getUrl());
+            }
+
+            return playlistId;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get playlist id");
+        }
+    }
+
+    @Override
+    public String getPlaylistName() throws ParsingException {
+        try {
+            if (playlistName == null) {
+                playlistName = doc.select("div[id=pl-header] h1[class=pl-header-title]").first().text();
+            }
+
+            return playlistName;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get playlist name");
+        }
+    }
+
+    @Override
+    public String getAvatarUrl() throws ParsingException {
+        try {
+            if (avatarUrl == null) {
+                avatarUrl = doc.select("div[id=pl-header] div[class=pl-header-thumb] img").first().attr("abs:src");
+            }
+
+            return avatarUrl;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get playlist avatar");
+        }
+    }
+
+    @Override
+    public String getBannerUrl() throws ParsingException {
+        try {
+            if (bannerUrl == null) {
+                Element el = doc.select("div[id=\"gh-banner\"] style").first();
+                String cssContent = el.html();
+                String url = "https:" + Parser.matchGroup1("url\\((.*)\\)", cssContent);
+                if (url.contains("s.ytimg.com")) {
+                    bannerUrl = null;
+                } else {
+                    bannerUrl = url.substring(0, url.indexOf(");"));
+                }
+            }
+
+            return bannerUrl;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get playlist Banner");
+        }
+    }
+
+    @Override
+    public String getUploaderUrl() throws ParsingException {
+        try {
+            if (uploaderUrl == null) {
+                uploaderUrl = doc.select("ul[class=\"pl-header-details\"] li").first().select("a").first().attr("abs:href");
+            }
+
+            return uploaderUrl;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get playlist uploader name");
+        }
+    }
+
+    @Override
+    public String getUploaderName() throws ParsingException {
+        try {
+            if (uploaderName == null) {
+                uploaderName = doc.select("span[class=\"qualified-channel-title-text\"]").first().select("a").first().text();
+            }
+
+            return uploaderName;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get playlist uploader name");
+        }
+    }
+
+    @Override
+    public String getUploaderAvatarUrl() throws ParsingException {
+        try {
+            if (uploaderAvatarUrl == null) {
+                uploaderAvatarUrl = doc.select("div[id=gh-banner] img[class=channel-header-profile-image]").first().attr("abs:src");
+            }
+
+            return uploaderAvatarUrl;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get playlist uploader avatar");
+        }
+    }
+
+    @Override
+    public long getStreamsCount() throws ParsingException {
+        if (streamsCount <= 0) {
+            String input;
+
+            try {
+                input = doc.select("ul[class=\"pl-header-details\"] li").get(1).text();
+            } catch (IndexOutOfBoundsException e) {
+                throw new ParsingException("Could not get video count from playlist", e);
+            }
+
+            try {
+                streamsCount = Long.parseLong(Utils.removeNonDigitCharacters(input));
+            } catch (NumberFormatException e) {
+                // When there's no videos in a playlist, there's no number in the "innerHtml",
+                // all characters that is not a number is removed, so we try to parse a empty string
+                if (!input.isEmpty()) {
+                    streamsCount = 0;
+                } else {
+                    throw new ParsingException("Could not handle input: " + input, e);
+                }
+            }
+        }
+
+        return streamsCount;
+    }
+
+    @Override
+    public StreamInfoItemCollector getStreams() throws ParsingException {
+        StreamInfoItemCollector collector = getStreamPreviewInfoCollector();
+        Element tbody = doc.select("tbody[id=\"pl-load-more-destination\"]").first();
+        collectStreamsFrom(collector, tbody);
+        return collector;
+    }
+
+    @Override
+    public StreamInfoItemCollector getNextStreams() throws ExtractionException, IOException {
+        if (!hasMoreStreams()){
+            throw new ExtractionException("Playlist doesn't have more streams");
+        }
+
+        StreamInfoItemCollector collector = new StreamInfoItemCollector(getServiceId());
+        setupNextStreamsAjax(NewPipe.getDownloader());
+        collectStreamsFrom(collector, nextStreamsAjax.select("tbody[id=\"pl-load-more-destination\"]").first());
+
+        return collector;
+    }
+
+    private void setupNextStreamsAjax(Downloader downloader) throws IOException, ReCaptchaException, ParsingException {
+        String ajaxDataRaw = downloader.download(nextStreamsUrl);
+        try {
+            JSONObject ajaxData = new JSONObject(ajaxDataRaw);
+
+            String htmlDataRaw = "<table><tbody id=\"pl-load-more-destination\">" + ajaxData.getString("content_html") + "</tbody></table>";
+            nextStreamsAjax = Jsoup.parse(htmlDataRaw, nextStreamsUrl);
+
+            String nextStreamsHtmlDataRaw = ajaxData.getString("load_more_widget_html");
+            if (!nextStreamsHtmlDataRaw.isEmpty()) {
+                final Document nextStreamsData = Jsoup.parse(nextStreamsHtmlDataRaw, nextStreamsUrl);
+                nextStreamsUrl = getNextStreamsUrl(nextStreamsData);
+            } else {
+                nextStreamsUrl = "";
+            }
+        } catch (JSONException e) {
+            throw new ParsingException("Could not parse json data for next streams", e);
+        }
+    }
+
+    private void fetchDocument() throws IOException, ReCaptchaException, ParsingException {
+        Downloader downloader = NewPipe.getDownloader();
+
+        String pageContent = downloader.download(getUrl());
+        doc = Jsoup.parse(pageContent, getUrl());
+
+        nextStreamsUrl = getNextStreamsUrl(doc);
+        nextStreamsAjax = null;
+    }
+
+    private String getNextStreamsUrl(Document d) throws ParsingException {
+        try {
+            Element button = d.select("button[class*=\"yt-uix-load-more\"]").first();
+            if (button != null) {
+                return button.attr("abs:data-uix-load-more-href");
+            } else {
+                // Sometimes playlists are simply so small, they don't have a more streams/videos
+                return "";
+            }
+        } catch (Exception e) {
+            throw new ParsingException("could not get next streams' url", e);
+        }
+    }
+
+    private void collectStreamsFrom(StreamInfoItemCollector collector, Element element) throws ParsingException {
+        collector.getItemList().clear();
+
+        final YoutubeStreamUrlIdHandler youtubeStreamUrlIdHandler = YoutubeStreamUrlIdHandler.getInstance();
+        for (final Element li : element.children()) {
+            collector.commit(new StreamInfoItemExtractor() {
+                @Override
+                public StreamType getStreamType() throws ParsingException {
+                    return StreamType.VIDEO_STREAM;
+                }
+
+                @Override
+                public String getWebPageUrl() throws ParsingException {
+                    try {
+                        return youtubeStreamUrlIdHandler.getUrl(li.attr("data-video-id"));
+                    } catch (Exception e) {
+                        throw new ParsingException("Could not get web page url for the video", e);
+                    }
+                }
+
+                @Override
+                public String getTitle() throws ParsingException {
+                    try {
+                        return li.attr("data-title");
+                    } catch (Exception e) {
+                        throw new ParsingException("Could not get title", e);
+                    }
+                }
+
+                @Override
+                public int getDuration() throws ParsingException {
+                    try {
+                        return YoutubeParsingHelper.parseDurationString(
+                                li.select("div[class=\"timestamp\"] span").first().text().trim());
+                    } catch (Exception e) {
+                        if (isLiveStream(li)) {
+                            // -1 for no duration
+                            return -1;
+                        } else {
+                            throw new ParsingException("Could not get Duration: " + getTitle(), e);
+                        }
+                    }
+                }
+
+                @Override
+                public String getUploader() throws ParsingException {
+                    return li.select("div[class=pl-video-owner] a").text();
+                }
+
+                @Override
+                public String getUploadDate() throws ParsingException {
+                    return "";
+                }
+
+                @Override
+                public long getViewCount() throws ParsingException {
+                    return -1;
+                }
+
+                @Override
+                public String getThumbnailUrl() throws ParsingException {
+                    try {
+                        return "https://i.ytimg.com/vi/" + youtubeStreamUrlIdHandler.getId(getWebPageUrl()) + "/hqdefault.jpg";
+                    } catch (Exception e) {
+                        throw new ParsingException("Could not get thumbnail url", e);
+                    }
+                }
+
+                @Override
+                public boolean isAd() throws ParsingException {
+                    return false;
+                }
+
+                private boolean isLiveStream(Element item) {
+                    Element bla = item.select("span[class*=\"yt-badge-live\"]").first();
+
+                    if (bla == null) {
+                        // sometimes livestreams dont have badges but sill are live streams
+                        // if video time is not available we most likly have an offline livestream
+                        if (item.select("span[class*=\"video-time\"]").first() == null) {
+                            return true;
+                        }
+                    }
+                    return bla != null;
+                }
+            });
+        }
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubePlaylistUrlIdHandler.java

@@ -0,0 +1,42 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.utils.Parser;
+
+public class YoutubePlaylistUrlIdHandler implements UrlIdHandler {
+
+    private static final YoutubePlaylistUrlIdHandler instance = new YoutubePlaylistUrlIdHandler();
+    private static final String ID_PATTERN = "([\\-a-zA-Z0-9_]{34})";
+
+    public static YoutubePlaylistUrlIdHandler getInstance() {
+        return instance;
+    }
+
+    @Override
+    public String getUrl(String listId) {
+        return "https://www.youtube.com/playlist?list=" + listId;
+    }
+
+    @Override
+    public String getId(String url) throws ParsingException {
+        try {
+            return Parser.matchGroup1("list=" + ID_PATTERN, url);
+        } catch (final Exception exception) {
+            throw new ParsingException("Error could not parse url :" + exception.getMessage(), exception);
+        }
+    }
+
+    @Override
+    public String cleanUrl(String complexUrl) throws ParsingException {
+        return getUrl(getId(complexUrl));
+    }
+
+    @Override
+    public boolean acceptUrl(String videoUrl) {
+        final boolean hasNotEmptyUrl = videoUrl != null && !videoUrl.isEmpty();
+        final boolean isYoutubeDomain = hasNotEmptyUrl && (videoUrl.contains("youtube") || videoUrl.contains("youtu.be"));
+        return isYoutubeDomain && videoUrl.contains("list=");
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeSearchEngine.java

@@ -0,0 +1,117 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.search.InfoItemSearchCollector;
+import org.schabi.newpipe.extractor.search.SearchEngine;
+
+import java.io.IOException;
+import java.net.URLEncoder;
+import java.util.EnumSet;
+
+
+/*
+ * Created by Christian Schabesberger on 09.08.15.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * YoutubeSearchEngine.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class YoutubeSearchEngine extends SearchEngine {
+
+    private static final String TAG = YoutubeSearchEngine.class.toString();
+    public static final String CHARSET_UTF_8 = "UTF-8";
+
+    public YoutubeSearchEngine(int serviceId) {
+        super(serviceId);
+    }
+
+    @Override
+    public InfoItemSearchCollector search(String query,
+                                          int page,
+                                          String languageCode,
+                                          EnumSet<Filter> filter)
+            throws IOException, ExtractionException {
+        InfoItemSearchCollector collector = getInfoItemSearchCollector();
+
+
+        Downloader downloader = NewPipe.getDownloader();
+
+        String url = "https://www.youtube.com/results"
+                + "?q=" + URLEncoder.encode(query, CHARSET_UTF_8)
+                + "&page=" + Integer.toString(page + 1);
+        if (filter.contains(Filter.STREAM) && !filter.contains(Filter.CHANNEL)) {
+            url += "&sp=EgIQAQ%253D%253D";
+        } else if (!filter.contains(Filter.STREAM) && filter.contains(Filter.CHANNEL)) {
+            url += "&sp=EgIQAg%253D%253D";
+        }
+
+        String site;
+        //String url = builder.build().toString();
+        //if we've been passed a valid language code, append it to the URL
+        if (!languageCode.isEmpty()) {
+            //assert Pattern.matches("[a-z]{2}(-([A-Z]{2}|[0-9]{1,3}))?", languageCode);
+            site = downloader.download(url, languageCode);
+        } else {
+            site = downloader.download(url);
+        }
+
+        Document doc = Jsoup.parse(site, url);
+        Element list = doc.select("ol[class=\"item-section\"]").first();
+
+        for (Element item : list.children()) {
+            /* First we need to determine which kind of item we are working with.
+               Youtube depicts five different kinds of items on its search result page. These are
+               regular videos, playlists, channels, two types of video suggestions, and a "no video
+               found" item. Since we only want videos, we need to filter out all the others.
+               An example for this can be seen here:
+               https://www.youtube.com/results?search_query=asdf&page=1
+
+               We already applied a filter to the url, so we don't need to care about channels and
+               playlists now.
+            */
+
+            Element el;
+
+            // both types of spell correction item
+            if ((el = item.select("div[class*=\"spell-correction\"]").first()) != null) {
+                collector.setSuggestion(el.select("a").first().text());
+                if (list.children().size() == 1) {
+                    throw new NothingFoundException("Did you mean: " + el.select("a").first().text());
+                }
+                // search message item
+            } else if ((el = item.select("div[class*=\"search-message\"]").first()) != null) {
+                throw new NothingFoundException(el.text());
+
+                // video item type
+            } else if ((el = item.select("div[class*=\"yt-lockup-video\"]").first()) != null) {
+                collector.commit(new YoutubeStreamInfoItemExtractor(el));
+            } else if ((el = item.select("div[class*=\"yt-lockup-channel\"]").first()) != null) {
+                collector.commit(new YoutubeChannelInfoItemExtractor(el));
+            } else {
+                // noinspection ConstantConditions
+                // simply ignore not known items
+                // throw new ExtractionException("unexpected element found: \"" + item + "\"");
+            }
+        }
+
+        return collector;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeService.java

@@ -0,0 +1,94 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.schabi.newpipe.extractor.StreamingService;
+import org.schabi.newpipe.extractor.SuggestionExtractor;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.channel.ChannelExtractor;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.playlist.PlaylistExtractor;
+import org.schabi.newpipe.extractor.search.SearchEngine;
+import org.schabi.newpipe.extractor.stream.StreamExtractor;
+
+import java.io.IOException;
+
+
+/*
+ * Created by Christian Schabesberger on 23.08.15.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * YoutubeService.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class YoutubeService extends StreamingService {
+
+    public YoutubeService(int id) {
+        super(id);
+    }
+
+    @Override
+    public ServiceInfo getServiceInfo() {
+        ServiceInfo serviceInfo = new ServiceInfo();
+        serviceInfo.name = "Youtube";
+        return serviceInfo;
+    }
+
+    @Override
+    public StreamExtractor getStreamExtractorInstance(String url)
+            throws ExtractionException, IOException {
+        UrlIdHandler urlIdHandler = YoutubeStreamUrlIdHandler.getInstance();
+        if (urlIdHandler.acceptUrl(url)) {
+            return new YoutubeStreamExtractor(urlIdHandler, url, getServiceId());
+        } else {
+            throw new IllegalArgumentException("supplied String is not a valid Youtube URL");
+        }
+    }
+
+    @Override
+    public SearchEngine getSearchEngineInstance() {
+        return new YoutubeSearchEngine(getServiceId());
+    }
+
+    @Override
+    public UrlIdHandler getStreamUrlIdHandlerInstance() {
+        return YoutubeStreamUrlIdHandler.getInstance();
+    }
+
+    @Override
+    public UrlIdHandler getChannelUrlIdHandlerInstance() {
+        return YoutubeChannelUrlIdHandler.getInstance();
+    }
+
+
+    @Override
+    public UrlIdHandler getPlaylistUrlIdHandlerInstance() {
+        return YoutubePlaylistUrlIdHandler.getInstance();
+    }
+
+    @Override
+    public ChannelExtractor getChannelExtractorInstance(String url) throws ExtractionException, IOException {
+        return new YoutubeChannelExtractor(getChannelUrlIdHandlerInstance(), url, getServiceId());
+    }
+
+    @Override
+    public PlaylistExtractor getPlaylistExtractorInstance(String url) throws ExtractionException, IOException {
+        return new YoutubePlaylistExtractor(getPlaylistUrlIdHandlerInstance(), url, getServiceId());
+    }
+
+    @Override
+    public SuggestionExtractor getSuggestionExtractorInstance() {
+        return new YoutubeSuggestionExtractor(getServiceId());
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeStreamExtractor.java

@@ -0,0 +1,880 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Function;
+import org.mozilla.javascript.ScriptableObject;
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+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.stream.AudioStream;
+import org.schabi.newpipe.extractor.stream.Stream;
+import org.schabi.newpipe.extractor.stream.StreamExtractor;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemCollector;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemExtractor;
+import org.schabi.newpipe.extractor.stream.StreamType;
+import org.schabi.newpipe.extractor.stream.VideoStream;
+import org.schabi.newpipe.extractor.utils.Parser;
+import org.schabi.newpipe.extractor.utils.Utils;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Vector;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/*
+ * Created by Christian Schabesberger on 06.08.15.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * YoutubeStreamExtractor.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class YoutubeStreamExtractor extends StreamExtractor {
+    private static final String TAG = YoutubeStreamExtractor.class.getSimpleName();
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Exceptions
+    //////////////////////////////////////////////////////////////////////////*/
+
+    public class DecryptException extends ParsingException {
+        DecryptException(String message, Throwable cause) {
+            super(message, cause);
+        }
+    }
+
+    public class GemaException extends ContentNotAvailableException {
+        GemaException(String message) {
+            super(message);
+        }
+    }
+
+    public class LiveStreamException extends ContentNotAvailableException {
+        LiveStreamException(String message) {
+            super(message);
+        }
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////*/
+
+    private Document doc;
+    private final String dirtyUrl;
+
+    public YoutubeStreamExtractor(UrlIdHandler urlIdHandler, String pageUrl, int serviceId) throws ExtractionException, IOException {
+        super(urlIdHandler, urlIdHandler.cleanUrl(pageUrl), serviceId);
+        dirtyUrl = pageUrl;
+        fetchDocument();
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Impl
+    //////////////////////////////////////////////////////////////////////////*/
+
+    @Override
+    public String getId() throws ParsingException {
+        try {
+            return getUrlIdHandler().getId(getUrl());
+        } catch (Exception e) {
+            throw new ParsingException("Could not get stream id");
+        }
+    }
+
+    @Override
+    public String getTitle() throws ParsingException {
+        try {
+            if (playerArgs == null) {
+                return videoInfoPage.get("title");
+            }
+            //json player args method
+            return playerArgs.getString("title");
+        } catch (JSONException je) {//html <meta> method
+            je.printStackTrace();
+            System.err.println("failed to load title from JSON args; trying to extract it from HTML");
+            try { // fall through to fall-back
+                return doc.select("meta[name=title]").attr(CONTENT);
+            } catch (Exception e) {
+                throw new ParsingException("failed permanently to load title.", e);
+            }
+        }
+    }
+
+    @Override
+    public String getDescription() throws ParsingException {
+        try {
+            return doc.select("p[id=\"eow-description\"]").first().html();
+        } catch (Exception e) {//todo: add fallback method <-- there is no ... as long as i know
+            throw new ParsingException("failed to load description.", e);
+        }
+    }
+
+    @Override
+    public String getUploader() throws ParsingException {
+        try {
+            if (playerArgs == null) {
+                return videoInfoPage.get("author");
+            }
+            //json player args method
+            return playerArgs.getString("author");
+        } catch (JSONException je) {
+            je.printStackTrace();
+            System.err.println(
+                    "failed to load uploader name from JSON args; trying to extract it from HTML");
+        }
+        try {//fall through to fallback HTML method
+            return doc.select("div.yt-user-info").first().text();
+        } catch (Exception e) {
+            throw new ParsingException("failed permanently to load uploader name.", e);
+        }
+    }
+
+    @Override
+    public int getLength() throws ParsingException {
+        try {
+            if (playerArgs == null) {
+                return Integer.valueOf(videoInfoPage.get("length_seconds"));
+            }
+            return playerArgs.getInt("length_seconds");
+        } catch (JSONException e) {//todo: find fallback method
+            throw new ParsingException("failed to load video duration from JSON args", e);
+        }
+    }
+
+    @Override
+    public long getViewCount() throws ParsingException {
+        try {
+            String viewCountString = doc.select("meta[itemprop=interactionCount]").attr(CONTENT);
+            return Long.parseLong(viewCountString);
+        } catch (Exception e) {//todo: find fallback method
+            throw new ParsingException("failed to get number of views", e);
+        }
+    }
+
+    @Override
+    public String getUploadDate() throws ParsingException {
+        try {
+            return doc.select("meta[itemprop=datePublished]").attr(CONTENT);
+        } catch (Exception e) {//todo: add fallback method
+            throw new ParsingException("failed to get upload date.", e);
+        }
+    }
+
+    @Override
+    public String getThumbnailUrl() throws ParsingException {
+        //first attempt getting a small image version
+        //in the html extracting part we try to get a thumbnail with a higher resolution
+        // Try to get high resolution thumbnail if it fails use low res from the player instead
+        try {
+            return doc.select("link[itemprop=\"thumbnailUrl\"]").first().attr("abs:href");
+        } catch (Exception e) {
+            System.err.println("Could not find high res Thumbnail. Using low res instead");
+        }
+        try { //fall through to fallback
+            return playerArgs.getString("thumbnail_url");
+        } catch (JSONException je) {
+            throw new ParsingException(
+                    "failed to extract thumbnail URL from JSON args; trying to extract it from HTML", je);
+        } catch (NullPointerException ne) {
+            // Get from the video info page instead
+            return videoInfoPage.get("thumbnail_url");
+        }
+    }
+
+    @Override
+    public String getUploaderThumbnailUrl() throws ParsingException {
+        try {
+            return doc.select("a[class*=\"yt-user-photo\"]").first()
+                    .select("img").first()
+                    .attr("abs:data-thumb");
+        } catch (Exception e) {//todo: add fallback method
+            throw new ParsingException("failed to get uploader thumbnail URL.", e);
+        }
+    }
+
+    @Override
+    public String getDashMpdUrl() throws ParsingException {
+        try {
+            String dashManifestUrl;
+            if (videoInfoPage != null && videoInfoPage.containsKey("dashmpd")) {
+                dashManifestUrl = videoInfoPage.get("dashmpd");
+            } else if (playerArgs.has("dashmpd")) {
+                dashManifestUrl = playerArgs.getString("dashmpd");
+            } else {
+                return "";
+            }
+            if (!dashManifestUrl.contains("/signature/")) {
+                String encryptedSig = Parser.matchGroup1("/s/([a-fA-F0-9\\.]+)", dashManifestUrl);
+                String decryptedSig;
+
+                decryptedSig = decryptSignature(encryptedSig, decryptionCode);
+                dashManifestUrl = dashManifestUrl.replace("/s/" + encryptedSig, "/signature/" + decryptedSig);
+            }
+            return dashManifestUrl;
+        } catch (Exception e) {
+            throw new ParsingException(
+                    "Could not get \"dashmpd\" maybe VideoInfoPage is broken.", e);
+        }
+    }
+
+    @Override
+    public List<AudioStream> getAudioStreams() throws ParsingException {
+        Vector<AudioStream> audioStreams = new Vector<>();
+        try {
+            String encodedUrlMap;
+            // playerArgs could be null if the video is age restricted
+            if (playerArgs == null) {
+                if (videoInfoPage.containsKey("adaptive_fmts")) {
+                    encodedUrlMap = videoInfoPage.get("adaptive_fmts");
+                } else {
+                    return null;
+                }
+            } else {
+                if (playerArgs.has("adaptive_fmts")) {
+                    encodedUrlMap = playerArgs.getString("adaptive_fmts");
+                } else {
+                    return null;
+                }
+            }
+            for (String url_data_str : encodedUrlMap.split(",")) {
+                // This loop iterates through multiple streams, therefor tags
+                // is related to one and the same stream at a time.
+                Map<String, String> tags = Parser.compatParseMap(
+                        org.jsoup.parser.Parser.unescapeEntities(url_data_str, true));
+
+                int itag = Integer.parseInt(tags.get("itag"));
+
+                if (ItagItem.isSupported(itag)) {
+                    ItagItem itagItem = ItagItem.getItag(itag);
+                    if (itagItem.itagType == ItagItem.ItagType.AUDIO) {
+                        String streamUrl = tags.get("url");
+                        // if video has a signature: decrypt it and add it to the url
+                        if (tags.get("s") != null) {
+                            streamUrl = streamUrl + "&signature="
+                                    + decryptSignature(tags.get("s"), decryptionCode);
+                        }
+
+                        AudioStream audioStream = new AudioStream(streamUrl, itagItem.mediaFormatId, itagItem.avgBitrate);
+                        if (!Stream.containSimilarStream(audioStream, audioStreams)) {
+                            audioStreams.add(audioStream);
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            throw new ParsingException("Could not get audiostreams", e);
+        }
+        return audioStreams;
+    }
+
+    @Override
+    public List<VideoStream> getVideoStreams() throws ParsingException {
+        Vector<VideoStream> videoStreams = new Vector<>();
+
+        try {
+            String encodedUrlMap;
+            // playerArgs could be null if the video is age restricted
+            if (playerArgs == null) {
+                encodedUrlMap = videoInfoPage.get(URL_ENCODED_FMT_STREAM_MAP);
+            } else {
+                encodedUrlMap = playerArgs.getString(URL_ENCODED_FMT_STREAM_MAP);
+            }
+            for (String url_data_str : encodedUrlMap.split(",")) {
+                try {
+                    // This loop iterates through multiple streams, therefor tags
+                    // is related to one and the same stream at a time.
+                    Map<String, String> tags = Parser.compatParseMap(
+                            org.jsoup.parser.Parser.unescapeEntities(url_data_str, true));
+
+                    int itag = Integer.parseInt(tags.get("itag"));
+
+                    if (ItagItem.isSupported(itag)) {
+                        ItagItem itagItem = ItagItem.getItag(itag);
+                        if (itagItem.itagType == ItagItem.ItagType.VIDEO) {
+                            String streamUrl = tags.get("url");
+                            // if video has a signature: decrypt it and add it to the url
+                            if (tags.get("s") != null) {
+                                streamUrl = streamUrl + "&signature="
+                                        + decryptSignature(tags.get("s"), decryptionCode);
+                            }
+
+                            VideoStream videoStream = new VideoStream(streamUrl, itagItem.mediaFormatId, itagItem.resolutionString);
+                            if (!Stream.containSimilarStream(videoStream, videoStreams)) {
+                                videoStreams.add(videoStream);
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    //todo: dont log throw an error
+                    System.err.println("Could not get Video stream.");
+                    e.printStackTrace();
+                }
+            }
+
+        } catch (Exception e) {
+            throw new ParsingException("Failed to get video streams", e);
+        }
+
+        if (videoStreams.isEmpty()) {
+            throw new ParsingException("Failed to get any video stream");
+        }
+        return videoStreams;
+    }
+
+    @Override
+    public List<VideoStream> getVideoOnlyStreams() throws ParsingException {
+        Vector<VideoStream> videoOnlyStreams = new Vector<>();
+
+        try {
+            String encodedUrlMap;
+            // playerArgs could be null if the video is age restricted
+            if (playerArgs == null) {
+                if (videoInfoPage.containsKey("adaptive_fmts")) {
+                    encodedUrlMap = videoInfoPage.get("adaptive_fmts");
+                } else {
+                    return null;
+                }
+            } else {
+                if (playerArgs.has("adaptive_fmts")) {
+                    encodedUrlMap = playerArgs.getString("adaptive_fmts");
+                } else {
+                    return null;
+                }
+            }
+            for (String url_data_str : encodedUrlMap.split(",")) {
+                // This loop iterates through multiple streams, therefor tags
+                // is related to one and the same stream at a time.
+                Map<String, String> tags = Parser.compatParseMap(
+                        org.jsoup.parser.Parser.unescapeEntities(url_data_str, true));
+
+                int itag = Integer.parseInt(tags.get("itag"));
+
+                if (ItagItem.isSupported(itag)) {
+                    ItagItem itagItem = ItagItem.getItag(itag);
+                    if (itagItem.itagType == ItagItem.ItagType.VIDEO_ONLY) {
+                        String streamUrl = tags.get("url");
+                        // if video has a signature: decrypt it and add it to the url
+                        if (tags.get("s") != null) {
+                            streamUrl = streamUrl + "&signature="
+                                    + decryptSignature(tags.get("s"), decryptionCode);
+                        }
+
+                        VideoStream videoStream = new VideoStream(streamUrl, itagItem.mediaFormatId, itagItem.resolutionString, true);
+                        if (!Stream.containSimilarStream(videoStream, videoOnlyStreams)) {
+                            videoOnlyStreams.add(videoStream);
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            throw new ParsingException("Failed to get video only streams", e);
+        }
+
+        if (videoOnlyStreams.isEmpty()) {
+            throw new ParsingException("Failed to get any video only stream");
+        }
+        return videoOnlyStreams;
+    }
+
+    /**
+     * Attempts to parse (and return) the offset to start playing the video from.
+     *
+     * @return the offset (in seconds), or 0 if no timestamp is found.
+     */
+    @Override
+    public int getTimeStamp() throws ParsingException {
+        String timeStamp;
+        try {
+            timeStamp = Parser.matchGroup1("((#|&|\\?)t=\\d{0,3}h?\\d{0,3}m?\\d{1,3}s?)", dirtyUrl);
+        } catch (Parser.RegexException e) {
+            // catch this instantly since an url does not necessarily have to have a time stamp
+
+            // -2 because well the testing system will then know its the regex that failed :/
+            // not good i know
+            return -2;
+        }
+
+        if (!timeStamp.isEmpty()) {
+            try {
+                String secondsString = "";
+                String minutesString = "";
+                String hoursString = "";
+                try {
+                    secondsString = Parser.matchGroup1("(\\d{1,3})s", timeStamp);
+                    minutesString = Parser.matchGroup1("(\\d{1,3})m", timeStamp);
+                    hoursString = Parser.matchGroup1("(\\d{1,3})h", timeStamp);
+                } catch (Exception e) {
+                    //it could be that time is given in another method
+                    if (secondsString.isEmpty() //if nothing was got,
+                            && minutesString.isEmpty()//treat as unlabelled seconds
+                            && hoursString.isEmpty()) {
+                        secondsString = Parser.matchGroup1("t=(\\d+)", timeStamp);
+                    }
+                }
+
+                int seconds = secondsString.isEmpty() ? 0 : Integer.parseInt(secondsString);
+                int minutes = minutesString.isEmpty() ? 0 : Integer.parseInt(minutesString);
+                int hours = hoursString.isEmpty() ? 0 : Integer.parseInt(hoursString);
+
+                //don't trust BODMAS!
+                return seconds + (60 * minutes) + (3600 * hours);
+                //Log.d(TAG, "derived timestamp value:"+ret);
+                //the ordering varies internationally
+            } catch (ParsingException e) {
+                throw new ParsingException("Could not get timestamp.", e);
+            }
+        } else {
+            return 0;
+        }
+    }
+
+    @Override
+    public int getAgeLimit() throws ParsingException {
+        if (!isAgeRestricted) {
+            return 0;
+        }
+        try {
+            return Integer.valueOf(doc.head()
+                    .getElementsByAttributeValue("property", "og:restrictions:age")
+                    .attr(CONTENT).replace("+", ""));
+        } catch (Exception e) {
+            throw new ParsingException("Could not get age restriction");
+        }
+    }
+
+    @Override
+    public String getAverageRating() throws ParsingException {
+        try {
+            if (playerArgs == null) {
+                return videoInfoPage.get("avg_rating");
+            }
+            return playerArgs.getString("avg_rating");
+        } catch (JSONException e) {
+            throw new ParsingException("Could not get Average rating", e);
+        }
+    }
+
+    @Override
+    public int getLikeCount() throws ParsingException {
+        String likesString = "";
+        try {
+
+            Element button = doc.select("button.like-button-renderer-like-button").first();
+            try {
+                likesString = button.select("span.yt-uix-button-content").first().text();
+            } catch (NullPointerException e) {
+                //if this ckicks in our button has no content and thefore likes/dislikes are disabled
+                return -1;
+            }
+            return Integer.parseInt(Utils.removeNonDigitCharacters(likesString));
+        } catch (NumberFormatException nfe) {
+            throw new ParsingException(
+                    "failed to parse likesString \"" + likesString + "\" as integers", nfe);
+        } catch (Exception e) {
+            throw new ParsingException("Could not get like count", e);
+        }
+    }
+
+    @Override
+    public int getDislikeCount() throws ParsingException {
+        String dislikesString = "";
+        try {
+            Element button = doc.select("button.like-button-renderer-dislike-button").first();
+            try {
+                dislikesString = button.select("span.yt-uix-button-content").first().text();
+            } catch (NullPointerException e) {
+                //if this kicks in our button has no content and therefore likes/dislikes are disabled
+                return -1;
+            }
+            return Integer.parseInt(Utils.removeNonDigitCharacters(dislikesString));
+        } catch (NumberFormatException nfe) {
+            throw new ParsingException(
+                    "failed to parse dislikesString \"" + dislikesString + "\" as integers", nfe);
+        } catch (Exception e) {
+            throw new ParsingException("Could not get dislike count", e);
+        }
+    }
+
+    @Override
+    public StreamInfoItemExtractor getNextVideo() throws ParsingException {
+        try {
+            return extractVideoPreviewInfo(doc.select("div[class=\"watch-sidebar-section\"]").first()
+                    .select("li").first());
+        } catch (Exception e) {
+            throw new ParsingException("Could not get next video", e);
+        }
+    }
+
+    @Override
+    public StreamInfoItemCollector getRelatedVideos() throws ParsingException {
+        try {
+            StreamInfoItemCollector collector = getStreamPreviewInfoCollector();
+            Element ul = doc.select("ul[id=\"watch-related\"]").first();
+            if (ul != null) {
+                for (Element li : ul.children()) {
+                    // first check if we have a playlist. If so leave them out
+                    if (li.select("a[class*=\"content-link\"]").first() != null) {
+                        collector.commit(extractVideoPreviewInfo(li));
+                    }
+                }
+            }
+            return collector;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get related videos", e);
+        }
+    }
+
+    @Override
+    public String getChannelUrl() throws ParsingException {
+        try {
+            return doc.select("div[class=\"yt-user-info\"]").first().children()
+                    .select("a").first().attr("abs:href");
+        } catch (Exception e) {
+            throw new ParsingException("Could not get channel link", e);
+        }
+    }
+
+    @Override
+    public StreamType getStreamType() throws ParsingException {
+        //todo: if implementing livestream support this value should be generated dynamically
+        return StreamType.VIDEO_STREAM;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public String getErrorMessage() {
+        String errorMessage = doc.select("h1[id=\"unavailable-message\"]").first().text();
+        StringBuilder errorReason;
+
+        if (errorMessage == null || errorMessage.isEmpty()) {
+            errorReason = null;
+        } else if (errorMessage.contains("GEMA")) {
+            // Gema sometimes blocks youtube music content in germany:
+            // https://www.gema.de/en/
+            // Detailed description:
+            // https://en.wikipedia.org/wiki/GEMA_%28German_organization%29
+            errorReason = new StringBuilder("GEMA");
+        } else {
+            errorReason = new StringBuilder(errorMessage);
+            errorReason.append("  ");
+            errorReason.append(doc.select("[id=\"unavailable-submessage\"]").first().text());
+        }
+
+        return errorReason != null ? errorReason.toString() : null;
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////
+    // Utils
+    //////////////////////////////////////////////////////////////////////////*/
+
+    private JSONObject playerArgs;
+    private boolean isAgeRestricted;
+    private Map<String, String> videoInfoPage;
+
+    private static final String URL_ENCODED_FMT_STREAM_MAP = "url_encoded_fmt_stream_map";
+    private static final String HTTPS = "https:";
+    private static final String CONTENT = "content";
+
+    /**
+     * Sometimes if the html page of youtube is already downloaded, youtube web page will internally
+     * download the /get_video_info page. Since a certain date dashmpd url is only available over
+     * this /get_video_info page, so we always need to download this one to.
+     * <p>
+     * %%video_id%% will be replaced by the actual video id
+     * $$el_type$$ will be replaced by the actual el_type (se the declarations below)
+     */
+    private static final String GET_VIDEO_INFO_URL =
+            "https://www.youtube.com/get_video_info?video_id=%%video_id%%$$el_type$$&ps=default&eurl=&gl=US&hl=en";
+    // eltype is necessary for the url above
+    private static final String EL_INFO = "el=info";
+
+
+    // static values
+    private static final String DECRYPTION_FUNC_NAME = "decrypt";
+
+    // cached values
+    private static volatile String decryptionCode = "";
+
+    private void fetchDocument() throws IOException, ReCaptchaException, ParsingException {
+        Downloader downloader = NewPipe.getDownloader();
+
+        String pageContent = downloader.download(getUrl());
+        doc = Jsoup.parse(pageContent, getUrl());
+
+        JSONObject ytPlayerConfig;
+        String playerUrl;
+
+        String videoInfoUrl = GET_VIDEO_INFO_URL.replace("%%video_id%%", getId()).replace("$$el_type$$", "&" + EL_INFO);
+        String videoInfoPageString = downloader.download(videoInfoUrl);
+        videoInfoPage = Parser.compatParseMap(videoInfoPageString);
+
+        // Check if the video is age restricted
+        if (pageContent.contains("<meta property=\"og:restrictions:age")) {
+            playerUrl = getPlayerUrlFromRestrictedVideo(getUrl());
+            isAgeRestricted = true;
+        } else {
+            ytPlayerConfig = getPlayerConfig(pageContent);
+            playerArgs = getPlayerArgs(ytPlayerConfig);
+            playerUrl = getPlayerUrl(ytPlayerConfig);
+            isAgeRestricted = false;
+        }
+
+        if (decryptionCode.isEmpty()) {
+            decryptionCode = loadDecryptionCode(playerUrl);
+        }
+    }
+
+    private JSONObject getPlayerConfig(String pageContent) throws ParsingException {
+        try {
+            String ytPlayerConfigRaw =
+                    Parser.matchGroup1("ytplayer.config\\s*=\\s*(\\{.*?\\});", pageContent);
+            return new JSONObject(ytPlayerConfigRaw);
+        } catch (Parser.RegexException e) {
+            String errorReason = getErrorMessage();
+            switch (errorReason) {
+                case "GEMA":
+                    throw new GemaException(errorReason);
+                case "":
+                    throw new ContentNotAvailableException("Content not available: player config empty", e);
+                default:
+                    throw new ContentNotAvailableException("Content not available", e);
+            }
+        } catch (JSONException e) {
+            throw new ParsingException("Could not parse yt player config", e);
+        }
+    }
+
+    private JSONObject getPlayerArgs(JSONObject playerConfig) throws ParsingException {
+        JSONObject playerArgs;
+
+        //attempt to load the youtube js player JSON arguments
+        boolean isLiveStream = false; //used to determine if this is a livestream or not
+        try {
+            playerArgs = playerConfig.getJSONObject("args");
+
+            // check if we have a live stream. We need to filter it, since its not yet supported.
+            if ((playerArgs.has("ps") && playerArgs.get("ps").toString().equals("live"))
+                    || (playerArgs.get(URL_ENCODED_FMT_STREAM_MAP).toString().isEmpty())) {
+                isLiveStream = true;
+            }
+        } catch (JSONException e) {
+            throw new ParsingException("Could not parse yt player config", e);
+        }
+        if (isLiveStream) {
+            throw new LiveStreamException("This is a Life stream. Can't use those right now.");
+        }
+
+        return playerArgs;
+    }
+
+    private String getPlayerUrl(JSONObject playerConfig) throws ParsingException {
+        try {
+            // The Youtube service needs to be initialized by downloading the
+            // js-Youtube-player. This is done in order to get the algorithm
+            // for decrypting cryptic signatures inside certain stream urls.
+            String playerUrl;
+
+            JSONObject ytAssets = playerConfig.getJSONObject("assets");
+            playerUrl = ytAssets.getString("js");
+
+            if (playerUrl.startsWith("//")) {
+                playerUrl = HTTPS + playerUrl;
+            }
+            return playerUrl;
+        } catch (JSONException e) {
+            throw new ParsingException(
+                    "Could not load decryption code for the Youtube service.", e);
+        }
+    }
+
+    private String getPlayerUrlFromRestrictedVideo(String pageUrl) throws ParsingException, ReCaptchaException {
+        try {
+            Downloader downloader = NewPipe.getDownloader();
+            String playerUrl = "";
+            String videoId = getUrlIdHandler().getId(pageUrl);
+            String embedUrl = "https://www.youtube.com/embed/" + videoId;
+            String embedPageContent = downloader.download(embedUrl);
+            //todo: find out if this can be reapaced by Parser.matchGroup1()
+            Pattern assetsPattern = Pattern.compile("\"assets\":.+?\"js\":\\s*(\"[^\"]+\")");
+            Matcher patternMatcher = assetsPattern.matcher(embedPageContent);
+            while (patternMatcher.find()) {
+                playerUrl = patternMatcher.group(1);
+            }
+            playerUrl = playerUrl.replace("\\", "").replace("\"", "");
+
+            if (playerUrl.startsWith("//")) {
+                playerUrl = HTTPS + playerUrl;
+            }
+            return playerUrl;
+        } catch (IOException e) {
+            throw new ParsingException(
+                    "Could load decryption code form restricted video for the Youtube service.", e);
+        } catch (ReCaptchaException e) {
+            throw new ReCaptchaException("reCaptcha Challenge requested");
+        }
+    }
+
+    private String loadDecryptionCode(String playerUrl) throws DecryptException {
+        String decryptionFuncName;
+        String decryptionFunc;
+        String helperObjectName;
+        String helperObject;
+        String callerFunc = "function " + DECRYPTION_FUNC_NAME + "(a){return %%(a);}";
+        String decryptionCode;
+
+        try {
+            Downloader downloader = NewPipe.getDownloader();
+            if (!playerUrl.contains("https://youtube.com")) {
+                //sometimes the https://youtube.com part does not get send with
+                //than we have to add it by hand
+                playerUrl = "https://youtube.com" + playerUrl;
+            }
+            String playerCode = downloader.download(playerUrl);
+
+            decryptionFuncName =
+                    Parser.matchGroup("([\"\\'])signature\\1\\s*,\\s*([a-zA-Z0-9$]+)\\(", playerCode, 2);
+
+            String functionPattern = "("
+                    + decryptionFuncName.replace("$", "\\$")
+                    + "=function\\([a-zA-Z0-9_]+\\)\\{.+?\\})";
+            decryptionFunc = "var " + Parser.matchGroup1(functionPattern, playerCode) + ";";
+
+            helperObjectName = Parser
+                    .matchGroup1(";([A-Za-z0-9_\\$]{2})\\...\\(", decryptionFunc);
+
+            String helperPattern = "(var "
+                    + helperObjectName.replace("$", "\\$") + "=\\{.+?\\}\\};)";
+            helperObject = Parser.matchGroup1(helperPattern, playerCode);
+
+
+            callerFunc = callerFunc.replace("%%", decryptionFuncName);
+            decryptionCode = helperObject + decryptionFunc + callerFunc;
+        } catch (IOException ioe) {
+            throw new DecryptException("Could not load decrypt function", ioe);
+        } catch (Exception e) {
+            throw new DecryptException("Could not parse decrypt function ", e);
+        }
+
+        return decryptionCode;
+    }
+
+    private String decryptSignature(String encryptedSig, String decryptionCode) throws DecryptException {
+        Context context = Context.enter();
+        context.setOptimizationLevel(-1);
+        Object result = null;
+        try {
+            ScriptableObject scope = context.initStandardObjects();
+            context.evaluateString(scope, decryptionCode, "decryptionCode", 1, null);
+            Function decryptionFunc = (Function) scope.get("decrypt", scope);
+            result = decryptionFunc.call(context, scope, scope, new Object[]{encryptedSig});
+        } catch (Exception e) {
+            throw new DecryptException("could not get decrypt signature", e);
+        } finally {
+            Context.exit();
+        }
+        return result == null ? "" : result.toString();
+    }
+
+    /**
+     * Provides information about links to other videos on the video page, such as related videos.
+     * This is encapsulated in a StreamInfoItem object,
+     * which is a subset of the fields in a full StreamInfo.
+     */
+    private StreamInfoItemExtractor extractVideoPreviewInfo(final Element li) {
+        return new StreamInfoItemExtractor() {
+            @Override
+            public StreamType getStreamType() throws ParsingException {
+                return StreamType.VIDEO_STREAM;
+            }
+
+            @Override
+            public boolean isAd() throws ParsingException {
+                return !li.select("span[class*=\"icon-not-available\"]").isEmpty();
+            }
+
+            @Override
+            public String getWebPageUrl() throws ParsingException {
+                return li.select("a.content-link").first().attr("abs:href");
+            }
+
+            @Override
+            public String getTitle() throws ParsingException {
+                //todo: check NullPointerException causing
+                return li.select("span.title").first().text();
+                //this page causes the NullPointerException, after finding it by searching for "tjvg":
+                //https://www.youtube.com/watch?v=Uqg0aEhLFAg
+            }
+
+            @Override
+            public int getDuration() throws ParsingException {
+                return YoutubeParsingHelper.parseDurationString(
+                        li.select("span.video-time").first().text());
+            }
+
+            @Override
+            public String getUploader() throws ParsingException {
+                return li.select("span.g-hovercard").first().text();
+            }
+
+            @Override
+            public String getUploadDate() throws ParsingException {
+                return null;
+            }
+
+            @Override
+            public long getViewCount() throws ParsingException {
+                //this line is unused
+                //String views = li.select("span.view-count").first().text();
+
+                //Log.i(TAG, "title:"+info.title);
+                //Log.i(TAG, "view count:"+views);
+
+                try {
+                    return Long.parseLong(Utils.removeNonDigitCharacters(
+                            li.select("span.view-count").first().text()));
+                } catch (Exception e) {
+                    //related videos sometimes have no view count
+                    return 0;
+                }
+            }
+
+            @Override
+            public String getThumbnailUrl() throws ParsingException {
+                Element img = li.select("img").first();
+                String thumbnailUrl = img.attr("abs:src");
+                // Sometimes youtube sends links to gif files which somehow seem to not exist
+                // anymore. Items with such gif also offer a secondary image source. So we are going
+                // to use that if we caught such an item.
+                if (thumbnailUrl.contains(".gif")) {
+                    thumbnailUrl = img.attr("data-thumb");
+                }
+                if (thumbnailUrl.startsWith("//")) {
+                    thumbnailUrl = HTTPS + thumbnailUrl;
+                }
+                return thumbnailUrl;
+            }
+        };
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeStreamInfoItemExtractor.java

@@ -0,0 +1,179 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.jsoup.nodes.Element;
+import org.schabi.newpipe.extractor.exceptions.FoundAdException;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.stream.StreamInfoItemExtractor;
+import org.schabi.newpipe.extractor.stream.StreamType;
+import org.schabi.newpipe.extractor.utils.Utils;
+
+/*
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * YoutubeStreamInfoItemExtractor.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class YoutubeStreamInfoItemExtractor implements StreamInfoItemExtractor {
+
+    private final Element item;
+
+    public YoutubeStreamInfoItemExtractor(Element item) throws FoundAdException {
+        this.item = item;
+    }
+
+    @Override
+    public String getWebPageUrl() throws ParsingException {
+        try {
+            Element el = item.select("div[class*=\"yt-lockup-video\"").first();
+            Element dl = el.select("h3").first().select("a").first();
+            return dl.attr("abs:href");
+        } catch (Exception e) {
+            throw new ParsingException("Could not get web page url for the video", e);
+        }
+    }
+
+    @Override
+    public String getTitle() throws ParsingException {
+        try {
+            Element el = item.select("div[class*=\"yt-lockup-video\"").first();
+            Element dl = el.select("h3").first().select("a").first();
+            return dl.text();
+        } catch (Exception e) {
+            throw new ParsingException("Could not get title", e);
+        }
+    }
+
+    @Override
+    public int getDuration() throws ParsingException {
+        try {
+            return YoutubeParsingHelper.parseDurationString(
+                    item.select("span[class=\"video-time\"]").first().text());
+        } catch (Exception e) {
+            if (isLiveStream(item)) {
+                // -1 for no duration
+                return -1;
+            } else {
+                throw new ParsingException("Could not get Duration: " + getTitle(), e);
+            }
+        }
+    }
+
+    @Override
+    public String getUploader() throws ParsingException {
+        try {
+            return item.select("div[class=\"yt-lockup-byline\"]").first()
+                    .select("a").first()
+                    .text();
+        } catch (Exception e) {
+            throw new ParsingException("Could not get uploader", e);
+        }
+    }
+
+    @Override
+    public String getUploadDate() throws ParsingException {
+        try {
+            Element div = item.select("div[class=\"yt-lockup-meta\"]").first();
+            if (div == null) {
+                return null;
+            } else {
+                return div.select("li").first().text();
+            }
+        } catch (Exception e) {
+            throw new ParsingException("Could not get upload date", e);
+        }
+    }
+
+    @Override
+    public long getViewCount() throws ParsingException {
+        String output;
+        String input;
+        try {
+            Element div = item.select("div[class=\"yt-lockup-meta\"]").first();
+            if (div == null) {
+                return -1;
+            } else {
+                input = div.select("li").get(1)
+                        .text();
+            }
+        } catch (IndexOutOfBoundsException e) {
+            if (isLiveStream(item)) {
+                // -1 for no view count
+                return -1;
+            } else {
+                throw new ParsingException(
+                        "Could not parse yt-lockup-meta although available: " + getTitle(), e);
+            }
+        }
+
+        output = Utils.removeNonDigitCharacters(input);
+
+        try {
+            return Long.parseLong(output);
+        } catch (NumberFormatException e) {
+            // if this happens the video probably has no views
+            if (!input.isEmpty()) {
+                return 0;
+            } else {
+                throw new ParsingException("Could not handle input: " + input, e);
+            }
+        }
+    }
+
+    @Override
+    public String getThumbnailUrl() throws ParsingException {
+        try {
+            String url;
+            Element te = item.select("div[class=\"yt-thumb video-thumb\"]").first()
+                    .select("img").first();
+            url = te.attr("abs:src");
+            // Sometimes youtube sends links to gif files which somehow seem to not exist
+            // anymore. Items with such gif also offer a secondary image source. So we are going
+            // to use that if we've caught such an item.
+            if (url.contains(".gif")) {
+                url = te.attr("abs:data-thumb");
+            }
+            return url;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get thumbnail url", e);
+        }
+    }
+
+    @Override
+    public StreamType getStreamType() {
+        if (isLiveStream(item)) {
+            return StreamType.LIVE_STREAM;
+        } else {
+            return StreamType.VIDEO_STREAM;
+        }
+    }
+
+    @Override
+    public boolean isAd() throws ParsingException {
+        return !item.select("span[class*=\"icon-not-available\"]").isEmpty();
+    }
+
+    private boolean isLiveStream(Element item) {
+        Element bla = item.select("span[class*=\"yt-badge-live\"]").first();
+
+        if (bla == null) {
+            // sometimes livestreams dont have badges but sill are live streams
+            // if video time is not available we most likly have an offline livestream
+            if (item.select("span[class*=\"video-time\"]").first() == null) {
+                return true;
+            }
+        }
+        return bla != null;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeStreamUrlIdHandler.java

@@ -0,0 +1,164 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.exceptions.FoundAdException;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.exceptions.ReCaptchaException;
+import org.schabi.newpipe.extractor.utils.Parser;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URLDecoder;
+
+/*
+ * Created by Christian Schabesberger on 02.02.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * YoutubeStreamUrlIdHandler.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class YoutubeStreamUrlIdHandler implements UrlIdHandler {
+
+    private static final YoutubeStreamUrlIdHandler instance = new YoutubeStreamUrlIdHandler();
+    private static final String ID_PATTERN = "([\\-a-zA-Z0-9_]{11})";
+
+    private YoutubeStreamUrlIdHandler() {
+    }
+
+    public static YoutubeStreamUrlIdHandler getInstance() {
+        return instance;
+    }
+
+    @Override
+    public String getUrl(String videoId) {
+        return "https://www.youtube.com/watch?v=" + videoId;
+    }
+
+    @Override
+    public String getId(String url) throws ParsingException, IllegalArgumentException {
+        if (url.isEmpty()) {
+            throw new IllegalArgumentException("The url parameter should not be empty");
+        }
+
+        String id;
+        String lowercaseUrl = url.toLowerCase();
+        if (lowercaseUrl.contains("youtube")) {
+            if (url.contains("attribution_link")) {
+                try {
+                    String escapedQuery = Parser.matchGroup1("u=(.[^&|$]*)", url);
+                    String query = URLDecoder.decode(escapedQuery, "UTF-8");
+                    id = Parser.matchGroup1("v=" + ID_PATTERN, query);
+                } catch (UnsupportedEncodingException uee) {
+                    throw new ParsingException("Could not parse attribution_link", uee);
+                }
+            } else if (lowercaseUrl.contains("youtube.com/shared?ci=")) {
+                return getRealIdFromSharedLink(url);
+            } else if (url.contains("vnd.youtube")) {
+                id = Parser.matchGroup1(ID_PATTERN, url);
+            } else if (url.contains("embed")) {
+                id = Parser.matchGroup1("embed/" + ID_PATTERN, url);
+            } else if (url.contains("googleads")) {
+                throw new FoundAdException("Error found add: " + url);
+            } else {
+                id = Parser.matchGroup1("[?&]v=" + ID_PATTERN, url);
+            }
+        } else if (lowercaseUrl.contains("youtu.be")) {
+            if (url.contains("v=")) {
+                id = Parser.matchGroup1("v=" + ID_PATTERN, url);
+            } else {
+                id = Parser.matchGroup1("[Yy][Oo][Uu][Tt][Uu]\\.[Bb][Ee]/" + ID_PATTERN, url);
+            }
+        } else {
+            throw new ParsingException("Error no suitable url: " + url);
+        }
+
+
+        if (!id.isEmpty()) {
+            return id;
+        } else {
+            throw new ParsingException("Error could not parse url: " + url);
+        }
+    }
+
+    /**
+     * Get the real url from a shared uri.
+     * <p>
+     * Shared URI's look like this:
+     * <pre>
+     *     * https://www.youtube.com/shared?ci=PJICrTByb3E
+     *     * vnd.youtube://www.youtube.com/shared?ci=PJICrTByb3E&feature=twitter-deep-link
+     * </pre>
+     *
+     * @param url The shared url
+     * @return the id of the stream
+     * @throws ParsingException
+     */
+    private String getRealIdFromSharedLink(String url) throws ParsingException {
+        URI uri;
+        try {
+            uri = new URI(url);
+        } catch (URISyntaxException e) {
+            throw new ParsingException("Invalid shared link", e);
+        }
+        String sharedId = getSharedId(uri);
+        Downloader downloader = NewPipe.getDownloader();
+        String content;
+        try {
+            content = downloader.download("https://www.youtube.com/shared?ci=" + sharedId);
+        } catch (IOException | ReCaptchaException e) {
+            throw new ParsingException("Unable to resolve shared link", e);
+        }
+        // is this bad? is this fragile?:
+        String realId = Parser.matchGroup1("rel=\"shortlink\" href=\"https://youtu.be/" + ID_PATTERN, content);
+        if (sharedId.equals(realId)) {
+            throw new ParsingException("Got same id for as shared info_id: " + sharedId);
+        }
+        return realId;
+    }
+
+    private String getSharedId(URI uri) throws ParsingException {
+        if (!"/shared".equals(uri.getPath())) {
+            throw new ParsingException("Not a shared link: " + uri.toString() + " (path != " + uri.getPath() + ")");
+        }
+        return Parser.matchGroup1("ci=" + ID_PATTERN, uri.getQuery());
+    }
+
+    @Override
+    public String cleanUrl(String complexUrl) throws ParsingException {
+        return getUrl(getId(complexUrl));
+    }
+
+    @Override
+    public boolean acceptUrl(String videoUrl) {
+        String lowercaseUrl = videoUrl.toLowerCase();
+        if (lowercaseUrl.contains("youtube") ||
+                lowercaseUrl.contains("youtu.be")) {
+            // bad programming I know
+            try {
+                getId(videoUrl);
+                return true;
+            } catch (Exception e) {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+}

src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeSuggestionExtractor.java

@@ -0,0 +1,99 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.SuggestionExtractor;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+/*
+ * Created by Christian Schabesberger on 28.09.16.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * YoutubeSuggestionExtractor.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class YoutubeSuggestionExtractor extends SuggestionExtractor {
+
+    public static final String CHARSET_UTF_8 = "UTF-8";
+
+    public YoutubeSuggestionExtractor(int serviceId) {
+        super(serviceId);
+    }
+
+    @Override
+    public List<String> suggestionList(
+            String query, String contentCountry)
+            throws ExtractionException, IOException {
+        List<String> suggestions = new ArrayList<>();
+
+        Downloader dl = NewPipe.getDownloader();
+
+        String url = "https://suggestqueries.google.com/complete/search"
+                + "?client=" + ""
+                + "&output=" + "toolbar"
+                + "&ds=" + "yt"
+                + "&hl=" + URLEncoder.encode(contentCountry, CHARSET_UTF_8)
+                + "&q=" + URLEncoder.encode(query, CHARSET_UTF_8);
+
+
+        String response = dl.download(url);
+
+        //TODO: Parse xml data using Jsoup not done
+        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
+        DocumentBuilder dBuilder;
+        org.w3c.dom.Document doc = null;
+
+        try {
+            dBuilder = dbFactory.newDocumentBuilder();
+            doc = dBuilder.parse(new InputSource(
+                    new ByteArrayInputStream(response.getBytes(CHARSET_UTF_8))));
+            doc.getDocumentElement().normalize();
+        } catch (ParserConfigurationException | SAXException | IOException e) {
+            throw new ParsingException("Could not parse document.");
+        }
+
+        try {
+            NodeList nList = doc.getElementsByTagName("CompleteSuggestion");
+            for (int temp = 0; temp < nList.getLength(); temp++) {
+
+                NodeList nList1 = doc.getElementsByTagName("suggestion");
+                Node nNode1 = nList1.item(temp);
+                if (nNode1.getNodeType() == Node.ELEMENT_NODE) {
+                    org.w3c.dom.Element eElement = (org.w3c.dom.Element) nNode1;
+                    suggestions.add(eElement.getAttribute("data"));
+                }
+            }
+            return suggestions;
+        } catch (Exception e) {
+            throw new ParsingException("Could not get suggestions form document.", e);
+        }
+    }
+}

src/main/java/org/schabi/newpipe/extractor/stream/AudioStream.java

@@ -0,0 +1,36 @@
+package org.schabi.newpipe.extractor.stream;
+
+/*
+ * Created by Christian Schabesberger on 04.03.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * AudioStream.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class AudioStream extends Stream {
+    public int average_bitrate = -1;
+
+    public AudioStream(String url, int format, int averageBitrate) {
+        super(url, format);
+        this.average_bitrate = averageBitrate;
+    }
+
+    @Override
+    public boolean equalStats(Stream cmp) {
+        return super.equalStats(cmp) && cmp instanceof AudioStream &&
+                average_bitrate == ((AudioStream) cmp).average_bitrate;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/stream/Stream.java

@@ -0,0 +1,39 @@
+package org.schabi.newpipe.extractor.stream;
+
+import java.io.Serializable;
+import java.util.List;
+
+public abstract class Stream implements Serializable {
+    public String url;
+    public int format = -1;
+
+    public Stream(String url, int format) {
+        this.url = url;
+        this.format = format;
+    }
+
+    /**
+     * Reveals whether two streams are the same, but have different urls
+     */
+    public boolean equalStats(Stream cmp) {
+        return cmp != null && format == cmp.format;
+    }
+
+    /**
+     * Reveals whether two Streams are equal
+     */
+    public boolean equals(Stream cmp) {
+        return equalStats(cmp) && url.equals(cmp.url);
+    }
+
+    /**
+     * Check if the list already contains one stream with equals stats
+     */
+    public static boolean containSimilarStream(Stream stream, List<? extends Stream> streamList) {
+        if (stream == null || streamList == null) return false;
+        for (Stream cmpStream : streamList) {
+            if (stream.equalStats(cmpStream)) return true;
+        }
+        return false;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/stream/StreamExtractor.java

@@ -0,0 +1,69 @@
+package org.schabi.newpipe.extractor.stream;
+
+/*
+ * Created by Christian Schabesberger on 10.08.15.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * StreamExtractor.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import org.schabi.newpipe.extractor.Extractor;
+import org.schabi.newpipe.extractor.UrlIdHandler;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.exceptions.ReCaptchaException;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Scrapes information from a video streaming service (eg, YouTube).
+ */
+public abstract class StreamExtractor extends Extractor {
+
+    public StreamExtractor(UrlIdHandler urlIdHandler, String url, int serviceId) {
+        super(urlIdHandler, serviceId, url);
+    }
+
+    public abstract String getId() throws ParsingException;
+    public abstract int getTimeStamp() throws ParsingException;
+    public abstract String getTitle() throws ParsingException;
+    public abstract String getDescription() throws ParsingException;
+    public abstract String getUploader() throws ParsingException;
+    public abstract String getChannelUrl() throws ParsingException;
+    public abstract int getLength() throws ParsingException;
+    public abstract long getViewCount() throws ParsingException;
+    public abstract String getUploadDate() throws ParsingException;
+    public abstract String getThumbnailUrl() throws ParsingException;
+    public abstract String getUploaderThumbnailUrl() throws ParsingException;
+    public abstract List<AudioStream> getAudioStreams() throws ParsingException, ReCaptchaException, IOException;
+    public abstract List<VideoStream> getVideoStreams() throws ParsingException;
+    public abstract List<VideoStream> getVideoOnlyStreams() throws ParsingException;
+    public abstract String getDashMpdUrl() throws ParsingException;
+    public abstract int getAgeLimit() throws ParsingException;
+    public abstract String getAverageRating() throws ParsingException;
+    public abstract int getLikeCount() throws ParsingException;
+    public abstract int getDislikeCount() throws ParsingException;
+    public abstract StreamInfoItemExtractor getNextVideo() throws ParsingException;
+    public abstract StreamInfoItemCollector getRelatedVideos() throws ParsingException, ReCaptchaException, IOException;
+    public abstract StreamType getStreamType() throws ParsingException;
+
+    /**
+     * Analyses the webpage's document and extracts any error message there might be.
+     *
+     * @return  Error message; null if there is no error message.
+     */
+    public abstract String getErrorMessage();
+}

src/main/java/org/schabi/newpipe/extractor/stream/StreamInfo.java

@@ -0,0 +1,284 @@
+package org.schabi.newpipe.extractor.stream;
+
+import org.schabi.newpipe.extractor.Info;
+import org.schabi.newpipe.extractor.InfoItem;
+import org.schabi.newpipe.extractor.exceptions.ContentNotAvailableException;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.utils.DashMpdParser;
+import org.schabi.newpipe.extractor.utils.Utils;
+
+import java.io.FileNotFoundException;
+import java.util.List;
+import java.util.Vector;
+
+/*
+ * Created by Christian Schabesberger on 26.08.15.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * StreamInfo.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Info object for opened videos, ie the video ready to play.
+ */
+@SuppressWarnings("WeakerAccess")
+public class StreamInfo extends Info {
+
+    public static class StreamExtractException extends ExtractionException {
+        StreamExtractException(String message) {
+            super(message);
+        }
+    }
+
+    public StreamInfo() {
+    }
+
+    /**
+     * Fills out the video info fields which are common to all services.
+     * Probably needs to be overridden by subclasses
+     */
+    public static StreamInfo getVideoInfo(StreamExtractor extractor) throws ExtractionException {
+        StreamInfo streamInfo = new StreamInfo();
+
+        try {
+            streamInfo = extractImportantData(streamInfo, extractor);
+            streamInfo = extractStreams(streamInfo, extractor);
+            streamInfo = extractOptionalData(streamInfo, extractor);
+        } catch (ExtractionException e) {
+            // Currently YouTube does not distinguish between age restricted videos and videos blocked
+            // by country.  This means that during the initialisation of the extractor, the extractor
+            // will assume that a video is age restricted while in reality it it blocked by country.
+            //
+            // We will now detect whether the video is blocked by country or not.
+            String errorMsg = extractor.getErrorMessage();
+
+            if (errorMsg != null) {
+                throw new ContentNotAvailableException(errorMsg);
+            } else {
+                throw e;
+            }
+        }
+
+        return streamInfo;
+    }
+
+    private static StreamInfo extractImportantData(StreamInfo streamInfo, StreamExtractor extractor) throws ExtractionException {
+        /* ---- important data, withoug the video can't be displayed goes here: ---- */
+        // if one of these is not available an exception is meant to be thrown directly into the frontend.
+
+        streamInfo.service_id = extractor.getServiceId();
+        streamInfo.url = extractor.getUrl();
+        streamInfo.stream_type = extractor.getStreamType();
+        streamInfo.id = extractor.getId();
+        streamInfo.name = extractor.getTitle();
+        streamInfo.age_limit = extractor.getAgeLimit();
+
+        if ((streamInfo.stream_type == StreamType.NONE)
+                || (streamInfo.url == null || streamInfo.url.isEmpty())
+                || (streamInfo.id == null || streamInfo.id.isEmpty())
+                || (streamInfo.name == null /* streamInfo.title can be empty of course */)
+                || (streamInfo.age_limit == -1)) {
+            throw new ExtractionException("Some important stream information was not given.");
+        }
+
+        return streamInfo;
+    }
+
+    private static StreamInfo extractStreams(StreamInfo streamInfo, StreamExtractor extractor) throws ExtractionException {
+        /* ---- stream extraction goes here ---- */
+        // At least one type of stream has to be available,
+        // otherwise an exception will be thrown directly into the frontend.
+
+        try {
+            streamInfo.dashMpdUrl = extractor.getDashMpdUrl();
+        } catch (Exception e) {
+            streamInfo.addException(new ExtractionException("Couldn't get Dash manifest", e));
+        }
+
+        /*  Load and extract audio */
+        try {
+            streamInfo.audio_streams = extractor.getAudioStreams();
+        } catch (Exception e) {
+            streamInfo.addException(new ExtractionException("Couldn't get audio streams", e));
+        }
+        /* Extract video stream url*/
+        try {
+            streamInfo.video_streams = extractor.getVideoStreams();
+        } catch (Exception e) {
+            streamInfo.addException(new ExtractionException("Couldn't get video streams", e));
+        }
+        /* Extract video only stream url*/
+        try {
+            streamInfo.video_only_streams = extractor.getVideoOnlyStreams();
+        } catch (Exception e) {
+            streamInfo.addException(new ExtractionException("Couldn't get video only streams", e));
+        }
+
+        // Lists can be null if a exception was thrown during extraction
+        if (streamInfo.video_streams == null) streamInfo.video_streams = new Vector<>();
+        if (streamInfo.video_only_streams == null) streamInfo.video_only_streams = new Vector<>();
+        if (streamInfo.audio_streams == null) streamInfo.audio_streams = new Vector<>();
+
+        if (streamInfo.dashMpdUrl != null && !streamInfo.dashMpdUrl.isEmpty()) {
+            try {
+                // Will try to find in the dash manifest for any stream that the ItagItem has (by the id),
+                // it has video, video only and audio streams and will only add to the list if it don't
+                // find a similar stream in the respective lists (calling Stream#equalStats).
+                DashMpdParser.getStreams(streamInfo);
+            } catch (Exception e) {
+                // Sometimes we receive 403 (forbidden) error when trying to download the manifest,
+                // (similar to https://github.com/rg3/youtube-dl/blob/master/youtube_dl/extractor/youtube.py#L1888)
+                // just skip the exception, as we later check if we have any streams
+                if (!Utils.hasCauseThrowable(e, FileNotFoundException.class)) {
+                    streamInfo.addException(new ExtractionException("Couldn't get streams from dash mpd", e));
+                }
+            }
+        }
+
+        // either dash_mpd audio_only or video has to be available, otherwise we didn't get a stream,
+        // and therefore failed. (Since video_only_streams are just optional they don't caunt).
+        if ((streamInfo.video_streams == null || streamInfo.video_streams.isEmpty())
+                && (streamInfo.audio_streams == null || streamInfo.audio_streams.isEmpty())
+                && (streamInfo.dashMpdUrl == null || streamInfo.dashMpdUrl.isEmpty())) {
+            throw new StreamExtractException(
+                    "Could not get any stream. See error variable to get further details.");
+        }
+
+        return streamInfo;
+    }
+
+    private static StreamInfo extractOptionalData(StreamInfo streamInfo, StreamExtractor extractor) {
+        /*  ---- optional data goes here: ---- */
+        // If one of these fails, the frontend needs to handle that they are not available.
+        // Exceptions are therefore not thrown into the frontend, but stored into the error List,
+        // so the frontend can afterwards check where errors happened.
+
+        try {
+            streamInfo.thumbnail_url = extractor.getThumbnailUrl();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            streamInfo.duration = extractor.getLength();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            streamInfo.uploader = extractor.getUploader();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            streamInfo.channel_url = extractor.getChannelUrl();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            streamInfo.description = extractor.getDescription();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            streamInfo.view_count = extractor.getViewCount();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            streamInfo.upload_date = extractor.getUploadDate();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            streamInfo.uploader_thumbnail_url = extractor.getUploaderThumbnailUrl();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            streamInfo.start_position = extractor.getTimeStamp();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            streamInfo.average_rating = extractor.getAverageRating();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            streamInfo.like_count = extractor.getLikeCount();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            streamInfo.dislike_count = extractor.getDislikeCount();
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            StreamInfoItemCollector c = new StreamInfoItemCollector(extractor.getServiceId());
+            StreamInfoItemExtractor nextVideo = extractor.getNextVideo();
+            c.commit(nextVideo);
+            if (c.getItemList().size() != 0) {
+                streamInfo.next_video = (StreamInfoItem) c.getItemList().get(0);
+            }
+            streamInfo.errors.addAll(c.getErrors());
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+        try {
+            // get related videos
+            StreamInfoItemCollector c = extractor.getRelatedVideos();
+            streamInfo.related_streams = c.getItemList();
+            streamInfo.errors.addAll(c.getErrors());
+        } catch (Exception e) {
+            streamInfo.addException(e);
+        }
+
+        return streamInfo;
+    }
+
+    public void addException(Exception e) {
+        errors.add(e);
+    }
+
+    public StreamType stream_type;
+    public String uploader;
+    public String thumbnail_url;
+    public String upload_date;
+    public long view_count = -1;
+
+    public String uploader_thumbnail_url;
+    public String channel_url;
+    public String description;
+
+    public List<VideoStream> video_streams;
+    public List<AudioStream> audio_streams;
+    public List<VideoStream> video_only_streams;
+    // video streams provided by the dash mpd do not need to be provided as VideoStream.
+    // Later on this will also aplly to audio streams. Since dash mpd is standarized,
+    // crawling such a file is not service dependent. Therefore getting audio only streams by yust
+    // providing the dash mpd fille will be possible in the future.
+    public String dashMpdUrl;
+    public int duration = -1;
+
+    public int age_limit = -1;
+    public int like_count = -1;
+    public int dislike_count = -1;
+    public String average_rating;
+    public StreamInfoItem next_video;
+    public List<InfoItem> related_streams = new Vector<>();
+    //in seconds. some metadata is not passed using a StreamInfo object!
+    public int start_position = 0;
+}

src/main/java/org/schabi/newpipe/extractor/stream/StreamInfoItem.java

@@ -0,0 +1,40 @@
+package org.schabi.newpipe.extractor.stream;
+
+/*
+ * Created by Christian Schabesberger on 26.08.15.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * StreamInfoItem.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import org.schabi.newpipe.extractor.InfoItem;
+
+/**
+ * Info object for previews of unopened videos, eg search results, related videos
+ */
+public class StreamInfoItem extends InfoItem {
+    public StreamType stream_type;
+
+    public String uploader;
+    public String thumbnail_url;
+    public String upload_date;
+    public long view_count = -1;
+    public int duration = -1;
+
+    public StreamInfoItem() {
+        super(InfoType.STREAM);
+    }
+}

src/main/java/org/schabi/newpipe/extractor/stream/StreamInfoItemCollector.java

@@ -0,0 +1,84 @@
+package org.schabi.newpipe.extractor.stream;
+
+import org.schabi.newpipe.extractor.InfoItemCollector;
+import org.schabi.newpipe.extractor.exceptions.FoundAdException;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+
+/*
+ * Created by Christian Schabesberger on 28.02.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * StreamInfoItemCollector.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class StreamInfoItemCollector extends InfoItemCollector {
+
+    public StreamInfoItemCollector(int serviceId) {
+        super(serviceId);
+    }
+
+    public StreamInfoItem extract(StreamInfoItemExtractor extractor) throws Exception {
+        if (extractor.isAd()) {
+            throw new FoundAdException("Found ad");
+        }
+
+        StreamInfoItem resultItem = new StreamInfoItem();
+        // important information
+        resultItem.service_id = getServiceId();
+        resultItem.url = extractor.getWebPageUrl();
+
+        resultItem.name = extractor.getTitle();
+        resultItem.stream_type = extractor.getStreamType();
+
+        // optional information
+        try {
+            resultItem.duration = extractor.getDuration();
+        } catch (Exception e) {
+            addError(e);
+        }
+        try {
+            resultItem.uploader = extractor.getUploader();
+        } catch (Exception e) {
+            addError(e);
+        }
+        try {
+            resultItem.upload_date = extractor.getUploadDate();
+        } catch (Exception e) {
+            addError(e);
+        }
+        try {
+            resultItem.view_count = extractor.getViewCount();
+        } catch (Exception e) {
+            addError(e);
+        }
+        try {
+            resultItem.thumbnail_url = extractor.getThumbnailUrl();
+        } catch (Exception e) {
+            addError(e);
+        }
+        return resultItem;
+    }
+
+    public void commit(StreamInfoItemExtractor extractor) throws ParsingException {
+        try {
+            addItem(extract(extractor));
+        } catch (FoundAdException ae) {
+            //System.out.println("AD_WARNING: " + ae.getMessage());
+        } catch (Exception e) {
+            addError(e);
+        }
+    }
+}

src/main/java/org/schabi/newpipe/extractor/stream/StreamInfoItemExtractor.java

@@ -0,0 +1,35 @@
+package org.schabi.newpipe.extractor.stream;
+
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+
+/*
+ * Created by Christian Schabesberger on 28.02.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * StreamInfoItemExtractor.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public interface StreamInfoItemExtractor {
+    StreamType getStreamType() throws ParsingException;
+    String getWebPageUrl() throws ParsingException;
+    String getTitle() throws ParsingException;
+    int getDuration() throws ParsingException;
+    String getUploader() throws ParsingException;
+    String getUploadDate() throws ParsingException;
+    long getViewCount() throws ParsingException;
+    String getThumbnailUrl() throws ParsingException;
+    boolean isAd() throws ParsingException;
+}

src/main/java/org/schabi/newpipe/extractor/stream/StreamType.java

@@ -0,0 +1,10 @@
+package org.schabi.newpipe.extractor.stream;
+
+public enum StreamType {
+    NONE,   // placeholder to check if stream type was checked or not
+    VIDEO_STREAM,
+    AUDIO_STREAM,
+    LIVE_STREAM,
+    AUDIO_LIVE_STREAM,
+    FILE
+}

src/main/java/org/schabi/newpipe/extractor/stream/VideoStream.java

@@ -0,0 +1,43 @@
+package org.schabi.newpipe.extractor.stream;
+
+/*
+ * Created by Christian Schabesberger on 04.03.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * VideoStream.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class VideoStream extends Stream {
+    public String resolution;
+    public boolean isVideoOnly;
+
+    public VideoStream(String url, int format, String res) {
+        this(url, format, res, false);
+    }
+
+    public VideoStream(String url, int format, String res, boolean isVideoOnly) {
+        super(url, format);
+        this.resolution = res;
+        this.isVideoOnly = isVideoOnly;
+    }
+
+    @Override
+    public boolean equalStats(Stream cmp) {
+        return super.equalStats(cmp) && cmp instanceof VideoStream &&
+                resolution.equals(((VideoStream) cmp).resolution) &&
+                isVideoOnly == ((VideoStream) cmp).isVideoOnly;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/utils/DashMpdParser.java

@@ -0,0 +1,114 @@
+package org.schabi.newpipe.extractor.utils;
+
+import org.schabi.newpipe.extractor.Downloader;
+import org.schabi.newpipe.extractor.MediaFormat;
+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.services.youtube.ItagItem;
+import org.schabi.newpipe.extractor.stream.AudioStream;
+import org.schabi.newpipe.extractor.stream.Stream;
+import org.schabi.newpipe.extractor.stream.StreamInfo;
+import org.schabi.newpipe.extractor.stream.VideoStream;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+/*
+ * Created by Christian Schabesberger on 02.02.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * DashMpdParser.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class DashMpdParser {
+
+    private DashMpdParser() {
+    }
+
+    public static class DashMpdParsingException extends ParsingException {
+        DashMpdParsingException(String message, Exception e) {
+            super(message, e);
+        }
+    }
+
+    /**
+     * Download manifest and return nodelist with elements of tag "AdaptationSet"
+     */
+    public static void getStreams(StreamInfo streamInfo) throws DashMpdParsingException, ReCaptchaException {
+        String dashDoc;
+        Downloader downloader = NewPipe.getDownloader();
+        try {
+            dashDoc = downloader.download(streamInfo.dashMpdUrl);
+        } catch (IOException ioe) {
+            throw new DashMpdParsingException("Could not get dash mpd: " + streamInfo.dashMpdUrl, ioe);
+        } catch (ReCaptchaException e) {
+            throw new ReCaptchaException("reCaptcha Challenge needed");
+        }
+
+        try {
+            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+            DocumentBuilder builder = factory.newDocumentBuilder();
+            InputStream stream = new ByteArrayInputStream(dashDoc.getBytes());
+
+            Document doc = builder.parse(stream);
+            NodeList representationList = doc.getElementsByTagName("Representation");
+
+            for (int i = 0; i < representationList.getLength(); i++) {
+                Element representation = ((Element) representationList.item(i));
+                try {
+                    String mimeType = ((Element) representation.getParentNode()).getAttribute("mimeType");
+                    String id = representation.getAttribute("id");
+                    String url = representation.getElementsByTagName("BaseURL").item(0).getTextContent();
+                    ItagItem itag = ItagItem.getItag(Integer.parseInt(id));
+                    if (itag != null) {
+                        MediaFormat mediaFormat = MediaFormat.getFromMimeType(mimeType);
+                        int format = mediaFormat != null ? mediaFormat.id : -1;
+
+                        if (itag.itagType.equals(ItagItem.ItagType.AUDIO)) {
+                            AudioStream audioStream = new AudioStream(url, format, itag.avgBitrate);
+
+                            if (!Stream.containSimilarStream(audioStream, streamInfo.audio_streams)) {
+                                streamInfo.audio_streams.add(audioStream);
+                            }
+                        } else {
+                            boolean isVideoOnly = itag.itagType.equals(ItagItem.ItagType.VIDEO_ONLY);
+                            VideoStream videoStream = new VideoStream(url, format, itag.resolutionString, isVideoOnly);
+
+                            if (isVideoOnly) {
+                                if (!Stream.containSimilarStream(videoStream, streamInfo.video_only_streams)) {
+                                    streamInfo.video_only_streams.add(videoStream);
+                                }
+                            } else if (!Stream.containSimilarStream(videoStream, streamInfo.video_streams)) {
+                                streamInfo.video_streams.add(videoStream);
+                            }
+                        }
+                    }
+                } catch (Exception ignored) {
+                }
+            }
+        } catch (Exception e) {
+            throw new DashMpdParsingException("Could not parse Dash mpd", e);
+        }
+    }
+}

src/main/java/org/schabi/newpipe/extractor/utils/Parser.java

@@ -0,0 +1,87 @@
+package org.schabi.newpipe.extractor.utils;
+
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/*
+ * Created by Christian Schabesberger on 02.02.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * Parser.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * avoid using regex !!!
+ */
+public class Parser {
+
+    private Parser() {
+    }
+
+    public static class RegexException extends ParsingException {
+        public RegexException(String message) {
+            super(message);
+        }
+    }
+
+    public static String matchGroup1(String pattern, String input) throws RegexException {
+        return matchGroup(pattern, input, 1);
+    }
+
+    public static String matchGroup(String pattern, String input, int group) throws RegexException {
+        Pattern pat = Pattern.compile(pattern);
+        Matcher mat = pat.matcher(input);
+        boolean foundMatch = mat.find();
+        if (foundMatch) {
+            return mat.group(group);
+        } else {
+            //Log.e(TAG, "failed to find pattern \""+pattern+"\" inside of \""+input+"\"");
+            if (input.length() > 1024) {
+                throw new RegexException("failed to find pattern \"" + pattern);
+            } else {
+                throw new RegexException("failed to find pattern \"" + pattern + " inside of " + input + "\"");
+            }
+        }
+    }
+
+    public static boolean isMatch(String pattern, String input) {
+        try {
+            matchGroup1(pattern, input);
+            return true;
+        } catch (RegexException e) {
+            return false;
+        }
+    }
+
+    public static Map<String, String> compatParseMap(final String input) throws UnsupportedEncodingException {
+        Map<String, String> map = new HashMap<>();
+        for (String arg : input.split("&")) {
+            String[] splitArg = arg.split("=");
+            if (splitArg.length > 1) {
+                map.put(splitArg[0], URLDecoder.decode(splitArg[1], "UTF-8"));
+            } else {
+                map.put(splitArg[0], "");
+            }
+        }
+        return map;
+    }
+}

src/main/java/org/schabi/newpipe/extractor/utils/Utils.java

@@ -0,0 +1,37 @@
+package org.schabi.newpipe.extractor.utils;
+
+public class Utils {
+    private Utils() {
+        //no instance
+    }
+
+    /**
+     * Remove all non-digit characters from a string.<p>
+     * Examples:<br/>
+     * <ul><li>1 234 567 views -> 1234567</li>
+     * <li>$ 31,133.124 -> 31133124</li></ul>
+     *
+     * @param toRemove string to remove non-digit chars
+     * @return a string that contains only digits
+     */
+    public static String removeNonDigitCharacters(String toRemove) {
+        return toRemove.replaceAll("\\D+", "");
+    }
+
+    /**
+     * Check if throwable have the cause
+     */
+    public static boolean hasCauseThrowable(Throwable throwable, Class<?> causeToCheck) {
+        // Check if getCause is not the same as cause (the getCause is already the root),
+        // as it will cause a infinite loop if it is
+        Throwable cause,  getCause = throwable;
+
+        while ((cause = throwable.getCause()) != null && getCause != cause) {
+            getCause = cause;
+            if (cause.getClass().isAssignableFrom(causeToCheck)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/test/java/org/schabi/newpipe/Downloader.java

@@ -0,0 +1,146 @@
+package org.schabi.newpipe;
+
+import org.schabi.newpipe.extractor.exceptions.ReCaptchaException;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.net.UnknownHostException;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import javax.net.ssl.HttpsURLConnection;
+
+
+/**
+ * Created by Christian Schabesberger on 28.01.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * Downloader.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+public class Downloader implements org.schabi.newpipe.extractor.Downloader {
+    
+    private static final String USER_AGENT = "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:43.0) Gecko/20100101 Firefox/43.0";
+    private static String mCookies = "";
+
+    private static Downloader instance = null;
+
+    private Downloader() {}
+
+    public static Downloader getInstance() {
+        if(instance == null) {
+            synchronized (Downloader.class) {
+                if (instance == null) {
+                    instance = new Downloader();
+                }
+            }
+        }
+        return instance;
+    }
+
+    public static synchronized void setCookies(String cookies) {
+        Downloader.mCookies = cookies;
+    }
+
+    public static synchronized String getCookies() {
+        return Downloader.mCookies;
+    }
+
+    /**Download the text file at the supplied URL as in download(String),
+     * but set the HTTP header field "Accept-Language" to the supplied string.
+     * @param siteUrl the URL of the text file to return the contents of
+     * @param language the language (usually a 2-character code) to set as the preferred language
+     * @return the contents of the specified text file*/
+    public String download(String siteUrl, String language) throws IOException, ReCaptchaException {
+        Map<String, String> requestProperties = new HashMap<>();
+        requestProperties.put("Accept-Language", language);
+        return download(siteUrl, requestProperties);
+    }
+
+
+    /**Download the text file at the supplied URL as in download(String),
+     * but set the HTTP header field "Accept-Language" to the supplied string.
+     * @param siteUrl the URL of the text file to return the contents of
+     * @param customProperties set request header properties
+     * @return the contents of the specified text file
+     * @throws IOException*/
+    public String download(String siteUrl, Map<String, String> customProperties) throws IOException, ReCaptchaException {
+        URL url = new URL(siteUrl);
+        HttpsURLConnection con = (HttpsURLConnection) url.openConnection();
+        Iterator it = customProperties.entrySet().iterator();
+        while(it.hasNext()) {
+            Map.Entry pair = (Map.Entry)it.next();
+            con.setRequestProperty((String)pair.getKey(), (String)pair.getValue());
+        }
+        return dl(con);
+    }
+
+    /**Common functionality between download(String url) and download(String url, String language)*/
+    private static String dl(HttpsURLConnection con) throws IOException, ReCaptchaException {
+        StringBuilder response = new StringBuilder();
+        BufferedReader in = null;
+
+        try {
+            con.setRequestMethod("GET");
+            con.setRequestProperty("User-Agent", USER_AGENT);
+
+            if (getCookies().length() > 0) {
+                con.setRequestProperty("Cookie", getCookies());
+            }
+
+            in = new BufferedReader(
+                    new InputStreamReader(con.getInputStream()));
+            String inputLine;
+
+            while((inputLine = in.readLine()) != null) {
+                response.append(inputLine);
+            }
+        } catch(UnknownHostException uhe) {//thrown when there's no internet connection
+            throw new IOException("unknown host or no network", uhe);
+            //Toast.makeText(getActivity(), uhe.getMessage(), Toast.LENGTH_LONG).show();
+        } catch(Exception e) {
+            /*
+             * HTTP 429 == Too Many Request
+             * Receive from Youtube.com = ReCaptcha challenge request
+             * See : https://github.com/rg3/youtube-dl/issues/5138
+             */
+            if (con.getResponseCode() == 429) {
+                throw new ReCaptchaException("reCaptcha Challenge requested");
+            }
+            throw new IOException(e);
+        } finally {
+            if(in != null) {
+                in.close();
+            }
+        }
+
+        return response.toString();
+    }
+
+    /**Download (via HTTP) the text file located at the supplied URL, and return its contents.
+     * Primarily intended for downloading web pages.
+     * @param siteUrl the URL of the text file to download
+     * @return the contents of the specified text file*/
+    public String download(String siteUrl) throws IOException, ReCaptchaException {
+        URL url = new URL(siteUrl);
+        HttpsURLConnection con = (HttpsURLConnection) url.openConnection();
+        //HttpsURLConnection con = NetCipher.getHttpsURLConnection(url);
+        return dl(con);
+    }
+}

src/test/java/org/schabi/newpipe/extractor/services/youtube/youtube/YoutubeChannelExtractorTest.java

@@ -0,0 +1,107 @@
+package org.schabi.newpipe.extractor.services.youtube.youtube;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.schabi.newpipe.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.channel.ChannelExtractor;
+
+/**
+ * Created by Christian Schabesberger on 12.09.16.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * YoutubeSearchEngineStreamTest.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Test for {@link ChannelExtractor}
+ */
+
+public class YoutubeChannelExtractorTest  {
+
+    ChannelExtractor extractor;
+
+    @Before
+    public void setUp() throws Exception {
+        NewPipe.init(Downloader.getInstance());
+        extractor = NewPipe.getService("Youtube")
+                .getChannelExtractorInstance("https://www.youtube.com/channel/UCYJ61XIK64sp6ZFFS8sctxw");
+    }
+
+    @Test
+    public void testGetDownloader()  throws Exception {
+        assertNotNull(NewPipe.getDownloader());
+    }
+
+    @Test
+    public void testGetChannelName() throws Exception {
+        assertEquals(extractor.getChannelName(), "Gronkh");
+    }
+
+    @Test
+    public void testGetAvatarUrl() throws Exception {
+        assertTrue(extractor.getAvatarUrl(), extractor.getAvatarUrl().contains("yt3"));
+    }
+
+    @Test
+    public void testGetBannerurl() throws Exception {
+        assertTrue(extractor.getBannerUrl(), extractor.getBannerUrl().contains("yt3"));
+    }
+
+    @Test
+    public void testGetFeedUrl() throws Exception {
+        assertTrue(extractor.getFeedUrl(), extractor.getFeedUrl().contains("feed"));
+    }
+
+    @Test
+    public void testGetStreams() throws Exception {
+        assertTrue("no streams are received", !extractor.getStreams().getItemList().isEmpty());
+    }
+
+    @Test
+    public void testGetStreamsErrors() throws Exception {
+        assertTrue("errors during stream list extraction", extractor.getStreams().getErrors().isEmpty());
+    }
+
+    @Test
+    public void testHasNextPage() throws Exception {
+        // this particular example (link) has a next page !!!
+        assertTrue("no next page link found", extractor.hasMoreStreams());
+    }
+
+    @Test
+    public void testGetSubscriberCount() throws Exception {
+        assertTrue("wrong subscriber count", extractor.getSubscriberCount() >= 0);
+    }
+
+    @Test
+    public void testGetNextPage() throws Exception {
+        extractor = NewPipe.getService("Youtube")
+                .getChannelExtractorInstance("https://www.youtube.com/channel/UCYJ61XIK64sp6ZFFS8sctxw");
+        assertTrue("next page didn't have content", !extractor.getStreams().getItemList().isEmpty());
+    }
+
+    @Test
+    public void testGetNextNextPageUrl() throws Exception {
+        extractor = NewPipe.getService("Youtube")
+                .getChannelExtractorInstance("https://www.youtube.com/channel/UCYJ61XIK64sp6ZFFS8sctxw");
+        assertTrue("next page didn't have content", extractor.hasMoreStreams());
+    }
+}

src/test/java/org/schabi/newpipe/extractor/services/youtube/youtube/YoutubeSearchEngineAllTest.java

@@ -0,0 +1,67 @@
+package org.schabi.newpipe.extractor.services.youtube.youtube;
+
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.EnumSet;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.schabi.newpipe.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.search.SearchEngine;
+import org.schabi.newpipe.extractor.search.SearchResult;
+
+
+/**
+ * Created by Christian Schabesberger on 29.12.15.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * YoutubeSearchEngineStreamTest.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Test for {@link SearchEngine}
+ */
+public class YoutubeSearchEngineAllTest {
+    private SearchResult result;
+
+    @Before
+    public void setUp() throws Exception {
+        NewPipe.init(Downloader.getInstance());
+        SearchEngine engine = NewPipe.getService("Youtube").getSearchEngineInstance();
+
+        result = engine.search("asdf", 0, "de",
+                EnumSet.of(SearchEngine.Filter.CHANNEL,
+                        SearchEngine.Filter.STREAM)).getSearchResult();
+    }
+
+    @Test
+    public void testResultList() {
+        assertFalse(result.resultList.isEmpty());
+    }
+
+    @Test
+    public void testResultErrors() {
+        assertTrue(result.errors == null || result.errors.isEmpty());
+    }
+
+    @Test
+    public void testSuggestion() {
+        //todo write a real test
+        assertTrue(result.suggestion != null);
+    }
+}

src/test/java/org/schabi/newpipe/extractor/services/youtube/youtube/YoutubeSearchEngineChannelTest.java

@@ -0,0 +1,73 @@
+package org.schabi.newpipe.extractor.services.youtube.youtube;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.EnumSet;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.schabi.newpipe.Downloader;
+import org.schabi.newpipe.extractor.InfoItem;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.search.SearchEngine;
+import org.schabi.newpipe.extractor.search.SearchResult;
+
+
+/**
+ * Created by Christian Schabesberger on 29.12.15.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * YoutubeSearchEngineStreamTest.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Test for {@link SearchEngine}
+ */
+public class YoutubeSearchEngineChannelTest {
+    private SearchResult result;
+
+    @Before
+    public void setUp() throws Exception {
+        NewPipe.init(Downloader.getInstance());
+        SearchEngine engine = NewPipe.getService("Youtube").getSearchEngineInstance();
+
+        result = engine.search("gronkh", 0, "de",
+                EnumSet.of(SearchEngine.Filter.CHANNEL)).getSearchResult();
+    }
+
+    @Test
+    public void testResultList() {
+        assertFalse(result.resultList.isEmpty());
+    }
+
+    @Test
+    public void testChannelItemType() {
+        assertEquals(result.resultList.get(0).info_type, InfoItem.InfoType.CHANNEL);
+    }
+
+    @Test
+    public void testResultErrors() {
+        assertTrue(result.errors == null || result.errors.isEmpty());
+    }
+
+    @Test
+    public void testSuggestion() {
+        //todo write a real test
+        assertTrue(result.suggestion != null);
+    }
+}

src/test/java/org/schabi/newpipe/extractor/services/youtube/youtube/YoutubeSearchEngineStreamTest.java

@@ -0,0 +1,73 @@
+package org.schabi.newpipe.extractor.services.youtube.youtube;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.EnumSet;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.schabi.newpipe.Downloader;
+import org.schabi.newpipe.extractor.InfoItem;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.search.SearchEngine;
+import org.schabi.newpipe.extractor.search.SearchResult;
+
+
+/**
+ * Created by Christian Schabesberger on 29.12.15.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * YoutubeSearchEngineStreamTest.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Test for {@link SearchEngine}
+ */
+public class YoutubeSearchEngineStreamTest {
+    private SearchResult result;
+
+    @Before
+    public void setUp() throws Exception {
+        NewPipe.init(Downloader.getInstance());
+        SearchEngine engine = NewPipe.getService("Youtube").getSearchEngineInstance();
+
+        result = engine.search("this is something boring", 0, "de",
+                EnumSet.of(SearchEngine.Filter.STREAM)).getSearchResult();
+    }
+
+    @Test
+    public void testResultList() {
+        assertFalse(result.resultList.isEmpty());
+    }
+
+    @Test
+    public void testChannelItemType() {
+        assertEquals(result.resultList.get(0).info_type, InfoItem.InfoType.STREAM);
+    }
+
+    @Test
+    public void testResultErrors() {
+        assertTrue(result.errors == null || result.errors.isEmpty());
+    }
+
+    @Test
+    public void testSuggestion() {
+        //todo write a real test
+        assertTrue(result.suggestion != null);
+    }
+}

src/test/java/org/schabi/newpipe/extractor/services/youtube/youtube/YoutubeSearchResultTest.java

@@ -0,0 +1,52 @@
+package org.schabi.newpipe.extractor.services.youtube.youtube;
+
+import static junit.framework.Assert.assertFalse;
+
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.schabi.newpipe.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.SuggestionExtractor;
+import org.schabi.newpipe.extractor.services.youtube.YoutubeSuggestionExtractor;
+
+/**
+ * Created by Christian Schabesberger on 18.11.16.
+ *
+ * Copyright (C) Christian Schabesberger 2016 <chris.schabesberger@mailbox.org>
+ * YoutubeSearchResultTest.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Test for {@link SuggestionExtractor}
+ */
+public class YoutubeSearchResultTest {
+    List<String> suggestionReply;
+
+
+    @Before
+    public void setUp() throws Exception {
+        NewPipe.init(Downloader.getInstance());
+        SuggestionExtractor engine = new YoutubeSuggestionExtractor(0);
+        suggestionReply = engine.suggestionList("hello", "de");
+    }
+
+    @Test
+    public void testIfSuggestions() {
+        assertFalse(suggestionReply.isEmpty());
+    }
+}

src/test/java/org/schabi/newpipe/extractor/services/youtube/youtube/YoutubeStreamExtractorDefaultTest.java

@@ -0,0 +1,141 @@
+package org.schabi.newpipe.extractor.services.youtube.youtube;
+
+import static junit.framework.Assert.assertTrue;
+
+import java.io.IOException;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.schabi.newpipe.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+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.stream.StreamExtractor;
+import org.schabi.newpipe.extractor.stream.StreamType;
+import org.schabi.newpipe.extractor.stream.VideoStream;
+
+/**
+ * Created by Christian Schabesberger on 30.12.15.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * YoutubeVideoExtractorDefault.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Test for {@link StreamExtractor}
+ */
+public class YoutubeStreamExtractorDefaultTest {
+    public static final String HTTPS = "https://";
+    private StreamExtractor extractor;
+
+    @Before
+    public void setUp() throws Exception {
+        NewPipe.init(Downloader.getInstance());
+        extractor = NewPipe.getService("Youtube")
+                .getStreamExtractorInstance("https://www.youtube.com/watch?v=YQHsXMglC9A");
+    }
+
+    @Test
+    public void testGetInvalidTimeStamp() throws ParsingException {
+        assertTrue(Integer.toString(extractor.getTimeStamp()),
+                extractor.getTimeStamp() <= 0);
+    }
+
+    @Test
+    public void testGetValidTimeStamp() throws ExtractionException, IOException {
+        StreamExtractor extractor =
+                NewPipe.getService("Youtube")
+                        .getStreamExtractorInstance("https://youtu.be/FmG385_uUys?t=174");
+        assertTrue(Integer.toString(extractor.getTimeStamp()),
+                extractor.getTimeStamp() == 174);
+    }
+
+    @Test
+    public void testGetTitle() throws ParsingException {
+        assertTrue(!extractor.getTitle().isEmpty());
+    }
+
+    @Test
+    public void testGetDescription() throws ParsingException {
+        assertTrue(extractor.getDescription() != null);
+    }
+
+    @Test
+    public void testGetUploader() throws ParsingException {
+        assertTrue(!extractor.getUploader().isEmpty());
+    }
+
+    @Test
+    public void testGetLength() throws ParsingException {
+        assertTrue(extractor.getLength() > 0);
+    }
+
+    @Test
+    public void testGetViewCount() throws ParsingException {
+        assertTrue(Long.toString(extractor.getViewCount()),
+                extractor.getViewCount() > /* specific to that video */ 1224000074);
+    }
+
+    @Test
+    public void testGetUploadDate() throws ParsingException {
+        assertTrue(extractor.getUploadDate().length() > 0);
+    }
+
+    @Test
+    public void testGetChannelUrl() throws ParsingException {
+        assertTrue(extractor.getChannelUrl().length() > 0);
+    }
+
+    @Test
+    public void testGetThumbnailUrl() throws ParsingException {
+        assertTrue(extractor.getThumbnailUrl(),
+                extractor.getThumbnailUrl().contains(HTTPS));
+    }
+
+    @Test
+    public void testGetUploaderThumbnailUrl() throws ParsingException {
+        assertTrue(extractor.getUploaderThumbnailUrl(),
+                extractor.getUploaderThumbnailUrl().contains(HTTPS));
+    }
+
+    @Test
+    public void testGetAudioStreams() throws ParsingException, ReCaptchaException, IOException {
+        assertTrue(!extractor.getAudioStreams().isEmpty());
+    }
+
+    @Test
+    public void testGetVideoStreams() throws ParsingException {
+        for(VideoStream s : extractor.getVideoStreams()) {
+            assertTrue(s.url,
+                    s.url.contains(HTTPS));
+            assertTrue(s.resolution.length() > 0);
+            assertTrue(Integer.toString(s.format),
+                    0 <= s.format && s.format <= 4);
+        }
+    }
+
+    @Test
+    public void testStreamType() throws ParsingException {
+        assertTrue(extractor.getStreamType() == StreamType.VIDEO_STREAM);
+    }
+
+    @Test
+    public void testGetDashMpd() throws ParsingException {
+        assertTrue(extractor.getDashMpdUrl(),
+                extractor.getDashMpdUrl() != null || !extractor.getDashMpdUrl().isEmpty());
+    }
+}

src/test/java/org/schabi/newpipe/extractor/services/youtube/youtube/YoutubeStreamExtractorGemaTest.java

@@ -0,0 +1,55 @@
+package org.schabi.newpipe.extractor.services.youtube.youtube;
+
+import static junit.framework.Assert.assertTrue;
+
+import java.io.IOException;
+
+import org.junit.Test;
+import org.schabi.newpipe.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.services.youtube.YoutubeStreamExtractor;
+
+/**
+ * Created by Christian Schabesberger on 30.12.15.
+ *
+ * Copyright (C) Christian Schabesberger 2015 <chris.schabesberger@mailbox.org>
+ * YoutubeVideoExtractorGema.java is part of NewPipe.
+ *
+ * NewPipe is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * NewPipe is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with NewPipe.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+// This class only works in Germany.
+/**
+ * Test for {@link YoutubeStreamExtractor}
+ */
+public class YoutubeStreamExtractorGemaTest {
+
+    // Deaktivate this Test Case bevore uploading it githup, otherwise CI will fail.
+    private static final boolean testActive = false;
+
+    @Test
+    public void testGemaError() throws IOException, ExtractionException {
+        if(testActive) {
+            try {
+                NewPipe.init(Downloader.getInstance());
+                NewPipe.getService("Youtube")
+                        .getStreamExtractorInstance("https://www.youtube.com/watch?v=3O1_3zBUKM8");
+            } catch(YoutubeStreamExtractor.GemaException ge) {
+                assertTrue(true);
+            }
+        }
+    }
+}

src/test/java/org/schabi/newpipe/extractor/services/youtube/youtube/YoutubeStreamExtractorRestrictedTest.java

@@ -0,0 +1,108 @@
+package org.schabi.newpipe.extractor.services.youtube.youtube;
+
+import static junit.framework.Assert.assertTrue;
+
+import java.io.IOException;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.schabi.newpipe.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.exceptions.ExtractionException;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.services.youtube.YoutubeStreamUrlIdHandler;
+import org.schabi.newpipe.extractor.stream.StreamExtractor;
+import org.schabi.newpipe.extractor.stream.VideoStream;
+
+/**
+ * Test for {@link YoutubeStreamUrlIdHandler}
+ */
+public class YoutubeStreamExtractorRestrictedTest {
+    public static final String HTTPS = "https://";
+    private StreamExtractor extractor;
+
+    @Before
+    public void setUp() throws Exception {
+        NewPipe.init(Downloader.getInstance());
+        extractor = NewPipe.getService("Youtube")
+                .getStreamExtractorInstance("https://www.youtube.com/watch?v=i6JTvzrpBy0");
+    }
+
+    @Test
+    public void testGetInvalidTimeStamp() throws ParsingException {
+        assertTrue(Integer.toString(extractor.getTimeStamp()),
+                extractor.getTimeStamp() <= 0);
+    }
+
+    @Test
+    public void testGetValidTimeStamp() throws ExtractionException, IOException {
+        StreamExtractor extractor= NewPipe.getService("Youtube")
+                .getStreamExtractorInstance("https://youtu.be/FmG385_uUys?t=174");
+        assertTrue(Integer.toString(extractor.getTimeStamp()),
+                extractor.getTimeStamp() == 174);
+    }
+
+    @Test
+    public void testGetAgeLimit() throws ParsingException {
+        assertTrue(extractor.getAgeLimit() == 18);
+    }
+
+    @Test
+    public void testGetTitle() throws ParsingException {
+        assertTrue(!extractor.getTitle().isEmpty());
+    }
+
+    @Test
+    public void testGetDescription() throws ParsingException {
+        assertTrue(extractor.getDescription() != null);
+    }
+
+    @Test
+    public void testGetUploader() throws ParsingException {
+        assertTrue(!extractor.getUploader().isEmpty());
+    }
+
+    @Test
+    public void testGetLength() throws ParsingException {
+        assertTrue(extractor.getLength() > 0);
+    }
+
+    @Test
+    public void testGetViews() throws ParsingException {
+        assertTrue(extractor.getLength() > 0);
+    }
+
+    @Test
+    public void testGetUploadDate() throws ParsingException {
+        assertTrue(extractor.getUploadDate().length() > 0);
+    }
+
+    @Test
+    public void testGetThumbnailUrl() throws ParsingException {
+        assertTrue(extractor.getThumbnailUrl(),
+                extractor.getThumbnailUrl().contains(HTTPS));
+    }
+
+    @Test
+    public void testGetUploaderThumbnailUrl() throws ParsingException {
+        assertTrue(extractor.getUploaderThumbnailUrl(),
+                extractor.getUploaderThumbnailUrl().contains(HTTPS));
+    }
+
+    @Test
+    public void testGetAudioStreams() throws ParsingException {
+        // audiostream not always necessary
+        //assertTrue(!extractor.getAudioStreams().isEmpty());
+    }
+
+    @Test
+    public void testGetVideoStreams() throws ParsingException {
+        for(VideoStream s : extractor.getVideoStreams()) {
+            assertTrue(s.url,
+                    s.url.contains(HTTPS));
+            assertTrue(s.resolution.length() > 0);
+            assertTrue(Integer.toString(s.format),
+                    0 <= s.format && s.format <= 4);
+        }
+    }
+}

src/test/java/org/schabi/newpipe/extractor/services/youtube/youtube/YoutubeStreamUrlIdHandlerTest.java

@@ -0,0 +1,119 @@
+package org.schabi.newpipe.extractor.services.youtube.youtube;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.fail;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.schabi.newpipe.Downloader;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.exceptions.FoundAdException;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.services.youtube.YoutubeStreamUrlIdHandler;
+
+/**
+ * Test for {@link YoutubeStreamUrlIdHandler}
+ */
+public class YoutubeStreamUrlIdHandlerTest {
+    private static String AD_URL = "https://googleads.g.doubleclick.net/aclk?sa=l&ai=C-2IPgeVTWPf4GcOStgfOnIOADf78n61GvKmmobYDrgIQASDj-5MDKAJg9ZXOgeAEoAGgy_T-A8gBAakC2gkpmquIsT6oAwGqBJMBT9BgD5kVgbN0dX602bFFaDw9vsxq-We-S8VkrXVBi6W_e7brZ36GCz1WO3EPEeklYuJjXLUowwCOKsd-8xr1UlS_tusuFJv9iX35xoBHKTRvs8-0aDbfEIm6in37QDfFuZjqgEMB8-tg0Jn_Pf1RU5OzbuU40B4Gy25NUTnOxhDKthOhKBUSZEksCEerUV8GMu10iAXCxquwApIFBggDEAEYAaAGGsgGlIjthrUDgAfItIsBqAemvhvYBwHSCAUIgGEQAbgT6AE&num=1&sig=AOD64_1DybDd4qAm5O7o9UAbTNRdqXXHFQ&ctype=21&video_id=dMO_IXYPZew&client=ca-pub-6219811747049371&adurl=http://www.youtube.com/watch%3Fv%3DdMO_IXYPZew";
+    private YoutubeStreamUrlIdHandler urlIdHandler;
+
+    @Before
+    public void setUp() throws Exception {
+        urlIdHandler = YoutubeStreamUrlIdHandler.getInstance();
+        NewPipe.init(Downloader.getInstance());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void getIdWithNullAsUrl() throws ParsingException {
+        urlIdHandler.getId(null);
+    }
+
+    @Test(expected = FoundAdException.class)
+    public void getIdForAd() throws ParsingException {
+        urlIdHandler.getId(AD_URL);
+    }
+
+    @Test
+    public void getIdForInvalidUrls() throws ParsingException {
+        List<String> invalidUrls = new ArrayList<>(50);
+        invalidUrls.add("https://www.youtube.com/watch?v=jZViOEv90d");
+        invalidUrls.add("https://www.youtube.com/watchjZViOEv90d");
+        invalidUrls.add("https://www.youtube.com/");
+        for(String invalidUrl: invalidUrls) {
+            Throwable exception = null;
+            try {
+                urlIdHandler.getId(invalidUrl);
+            } catch (ParsingException e) {
+                exception = e;
+            }
+            if(exception == null) {
+                fail("Expected ParsingException for url: " + invalidUrl);
+            }
+        }
+    }
+    @Test
+    public void getId() throws Exception {
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("https://www.youtube.com/watch?v=jZViOEv90dI"));
+        assertEquals("W-fFHeTX70Q", urlIdHandler.getId("https://www.youtube.com/watch?v=W-fFHeTX70Q"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("https://www.youtube.com/watch?v=jZViOEv90dI?t=100"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("https://WWW.YouTube.com/watch?v=jZViOEv90dI?t=100"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("HTTPS://www.youtube.com/watch?v=jZViOEv90dI?t=100"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("https://youtu.be/jZViOEv90dI?t=9s"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("HTTPS://Youtu.be/jZViOEv90dI?t=9s"));
+        assertEquals("uEJuoEs1UxY", urlIdHandler.getId("http://www.youtube.com/watch_popup?v=uEJuoEs1UxY"));
+        assertEquals("uEJuoEs1UxY", urlIdHandler.getId("http://www.Youtube.com/watch_popup?v=uEJuoEs1UxY"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("https://www.youtube.com/embed/jZViOEv90dI"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("https://www.youtube-nocookie.com/embed/jZViOEv90dI"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("http://www.youtube.com/watch?v=jZViOEv90dI"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("http://youtube.com/watch?v=jZViOEv90dI"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("http://youtu.be/jZViOEv90dI?t=9s"));
+        assertEquals("7_WWz2DSnT8", urlIdHandler.getId("https://youtu.be/7_WWz2DSnT8"));
+        assertEquals("oy6NvWeVruY", urlIdHandler.getId("https://m.youtube.com/watch?v=oy6NvWeVruY"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("http://www.youtube.com/embed/jZViOEv90dI"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("http://www.Youtube.com/embed/jZViOEv90dI"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("http://www.youtube-nocookie.com/embed/jZViOEv90dI"));
+        assertEquals("EhxJLojIE_o", urlIdHandler.getId("http://www.youtube.com/attribution_link?a=JdfC0C9V6ZI&u=%2Fwatch%3Fv%3DEhxJLojIE_o%26feature%3Dshare"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("vnd.youtube://www.youtube.com/watch?v=jZViOEv90dI"));
+        assertEquals("jZViOEv90dI", urlIdHandler.getId("vnd.youtube:jZViOEv90dI"));
+
+        // Shared links
+        String sharedId = "7JIArTByb3E";
+        String realId = "Q7JsK50NGaA";
+        assertEquals(realId, urlIdHandler.getId("vnd.youtube://www.YouTube.com/shared?ci=" + sharedId + "&feature=twitter-deep-link"));
+        assertEquals(realId, urlIdHandler.getId("vnd.youtube://www.youtube.com/shared?ci=" + sharedId ));
+        assertEquals(realId, urlIdHandler.getId("https://www.youtube.com/shared?ci=7JIArTByb3E"));
+
+    }
+
+
+    @Test
+    public void testAcceptUrl() {
+        assertTrue(urlIdHandler.acceptUrl("https://www.youtube.com/watch?v=jZViOEv90dI"));
+        assertTrue(urlIdHandler.acceptUrl("https://www.youtube.com/watch?v=jZViOEv90dI?t=100"));
+        assertTrue(urlIdHandler.acceptUrl("https://WWW.YouTube.com/watch?v=jZViOEv90dI?t=100"));
+        assertTrue(urlIdHandler.acceptUrl("HTTPS://www.youtube.com/watch?v=jZViOEv90dI?t=100"));
+        assertTrue(urlIdHandler.acceptUrl("https://youtu.be/jZViOEv90dI?t=9s"));
+        //assertTrue(urlIdHandler.acceptUrl("https://www.youtube.com/watch/jZViOEv90dI"));
+        assertTrue(urlIdHandler.acceptUrl("https://www.youtube.com/embed/jZViOEv90dI"));
+        assertTrue(urlIdHandler.acceptUrl("https://www.youtube-nocookie.com/embed/jZViOEv90dI"));
+        assertTrue(urlIdHandler.acceptUrl("http://www.youtube.com/watch?v=jZViOEv90dI"));
+        assertTrue(urlIdHandler.acceptUrl("http://youtu.be/jZViOEv90dI?t=9s"));
+        assertTrue(urlIdHandler.acceptUrl("http://www.youtube.com/embed/jZViOEv90dI"));
+        assertTrue(urlIdHandler.acceptUrl("http://www.youtube-nocookie.com/embed/jZViOEv90dI"));
+        assertTrue(urlIdHandler.acceptUrl("http://www.youtube.com/attribution_link?a=JdfC0C9V6ZI&u=%2Fwatch%3Fv%3DEhxJLojIE_o%26feature%3Dshare"));
+        assertTrue(urlIdHandler.acceptUrl("vnd.youtube://www.youtube.com/watch?v=jZViOEv90dI"));
+        assertTrue(urlIdHandler.acceptUrl("vnd.youtube:jZViOEv90dI"));
+
+        assertTrue(urlIdHandler.acceptUrl("vnd.youtube:jZViOEv90dI"));
+
+        String sharedId = "8A940MXKFmQ";
+        assertTrue(urlIdHandler.acceptUrl("vnd.youtube://www.youtube.com/shared?ci=" + sharedId + "&feature=twitter-deep-link"));
+        assertTrue(urlIdHandler.acceptUrl("vnd.youtube://www.youtube.com/shared?ci=" + sharedId ));
+        assertTrue(urlIdHandler.acceptUrl("https://www.youtube.com/shared?ci=" + sharedId));
+    }
+}