Move feed discovery backends to their own module

10 files changed, 747 insertions, 0 deletions

diff --git a/net/discovery/src/main/AndroidManifest.xml b/net/discovery/src/main/AndroidManifest.xml
new file mode 100644
index 000000000..3e42a802a
--- /dev/null
+++ b/net/discovery/src/main/AndroidManifest.xml
@@ -0,0 +1 @@
+<manifest package="de.danoeh.antennapod.net.discovery" />
diff --git a/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/CombinedSearcher.java b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/CombinedSearcher.java
new file mode 100644
index 000000000..6cbf8eb2e
--- /dev/null
+++ b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/CombinedSearcher.java
@@ -0,0 +1,118 @@
+package de.danoeh.antennapod.net.discovery;
+
+import android.text.TextUtils;
+import android.util.Log;
+import io.reactivex.Single;
+import io.reactivex.SingleOnSubscribe;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.schedulers.Schedulers;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+
+public class CombinedSearcher implements PodcastSearcher {
+    private static final String TAG = "CombinedSearcher";
+
+    public CombinedSearcher() {
+    }
+
+    public Single<List<PodcastSearchResult>> search(String query) {
+        ArrayList<Disposable> disposables = new ArrayList<>();
+        List<List<PodcastSearchResult>> singleResults = new ArrayList<>(
+                Collections.nCopies(PodcastSearcherRegistry.getSearchProviders().size(), null));
+        CountDownLatch latch = new CountDownLatch(PodcastSearcherRegistry.getSearchProviders().size());
+        for (int i = 0; i < PodcastSearcherRegistry.getSearchProviders().size(); i++) {
+            PodcastSearcherRegistry.SearcherInfo searchProviderInfo
+                    = PodcastSearcherRegistry.getSearchProviders().get(i);
+            PodcastSearcher searcher = searchProviderInfo.searcher;
+            if (searchProviderInfo.weight <= 0.00001f || searcher.getClass() == CombinedSearcher.class) {
+                latch.countDown();
+                continue;
+            }
+            final int index = i;
+            disposables.add(searcher.search(query).subscribe(e -> {
+                        singleResults.set(index, e);
+                        latch.countDown();
+                    }, throwable -> {
+                        Log.d(TAG, Log.getStackTraceString(throwable));
+                        latch.countDown();
+                    }
+            ));
+        }
+
+        return Single.create((SingleOnSubscribe<List<PodcastSearchResult>>) subscriber -> {
+            latch.await();
+            List<PodcastSearchResult> results = weightSearchResults(singleResults);
+            subscriber.onSuccess(results);
+        })
+                .doOnDispose(() -> {
+                    for (Disposable disposable : disposables) {
+                        if (disposable != null) {
+                            disposable.dispose();
+                        }
+                    }
+                })
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread());
+    }
+
+    private List<PodcastSearchResult> weightSearchResults(List<List<PodcastSearchResult>> singleResults) {
+        HashMap<String, Float> resultRanking = new HashMap<>();
+        HashMap<String, PodcastSearchResult> urlToResult = new HashMap<>();
+        for (int i = 0; i < singleResults.size(); i++) {
+            float providerPriority = PodcastSearcherRegistry.getSearchProviders().get(i).weight;
+            List<PodcastSearchResult> providerResults = singleResults.get(i);
+            if (providerResults == null) {
+                continue;
+            }
+            for (int position = 0; position < providerResults.size(); position++) {
+                PodcastSearchResult result = providerResults.get(position);
+                urlToResult.put(result.feedUrl, result);
+
+                float ranking = 0;
+                if (resultRanking.containsKey(result.feedUrl)) {
+                    ranking = resultRanking.get(result.feedUrl);
+                }
+                ranking += 1.f / (position + 1.f);
+                resultRanking.put(result.feedUrl, ranking * providerPriority);
+            }
+        }
+        List<Map.Entry<String, Float>> sortedResults = new ArrayList<>(resultRanking.entrySet());
+        Collections.sort(sortedResults, (o1, o2) -> Double.compare(o2.getValue(), o1.getValue()));
+
+        List<PodcastSearchResult> results = new ArrayList<>();
+        for (Map.Entry<String, Float> res : sortedResults) {
+            results.add(urlToResult.get(res.getKey()));
+        }
+        return results;
+    }
+
+    @Override
+    public Single<String> lookupUrl(String url) {
+        return PodcastSearcherRegistry.lookupUrl(url);
+    }
+
+    @Override
+    public boolean urlNeedsLookup(String url) {
+        return PodcastSearcherRegistry.urlNeedsLookup(url);
+    }
+
+    @Override
+    public String getName() {
+        ArrayList<String> names = new ArrayList<>();
+        for (int i = 0; i < PodcastSearcherRegistry.getSearchProviders().size(); i++) {
+            PodcastSearcherRegistry.SearcherInfo searchProviderInfo
+                    = PodcastSearcherRegistry.getSearchProviders().get(i);
+            PodcastSearcher searcher = searchProviderInfo.searcher;
+            if (searchProviderInfo.weight > 0.00001f && searcher.getClass() != CombinedSearcher.class) {
+                names.add(searcher.getName());
+            }
+        }
+        return TextUtils.join(", ", names);
+    }
+}
diff --git a/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/FyydPodcastSearcher.java b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/FyydPodcastSearcher.java
new file mode 100644
index 000000000..d4674c79d
--- /dev/null
+++ b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/FyydPodcastSearcher.java
@@ -0,0 +1,53 @@
+package de.danoeh.antennapod.net.discovery;
+
+import de.danoeh.antennapod.core.service.download.AntennapodHttpClient;
+import de.mfietz.fyydlin.FyydClient;
+import de.mfietz.fyydlin.FyydResponse;
+import de.mfietz.fyydlin.SearchHit;
+import io.reactivex.Single;
+import io.reactivex.SingleOnSubscribe;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.schedulers.Schedulers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FyydPodcastSearcher implements PodcastSearcher {
+    private final FyydClient client = new FyydClient(AntennapodHttpClient.getHttpClient());
+
+    public Single<List<PodcastSearchResult>> search(String query) {
+        return Single.create((SingleOnSubscribe<List<PodcastSearchResult>>) subscriber -> {
+            FyydResponse response = client.searchPodcasts(query, 10)
+                    .subscribeOn(Schedulers.io())
+                    .blockingGet();
+
+            ArrayList<PodcastSearchResult> searchResults = new ArrayList<>();
+
+            if (!response.getData().isEmpty()) {
+                for (SearchHit searchHit : response.getData()) {
+                    PodcastSearchResult podcast = PodcastSearchResult.fromFyyd(searchHit);
+                    searchResults.add(podcast);
+                }
+            }
+
+            subscriber.onSuccess(searchResults);
+        })
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread());
+    }
+
+    @Override
+    public Single<String> lookupUrl(String url) {
+        return Single.just(url);
+    }
+
+    @Override
+    public boolean urlNeedsLookup(String url) {
+        return false;
+    }
+
+    @Override
+    public String getName() {
+        return "Fyyd";
+    }
+}
diff --git a/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/GpodnetPodcastSearcher.java b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/GpodnetPodcastSearcher.java
new file mode 100644
index 000000000..222c415ab
--- /dev/null
+++ b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/GpodnetPodcastSearcher.java
@@ -0,0 +1,52 @@
+package de.danoeh.antennapod.net.discovery;
+
+import de.danoeh.antennapod.core.sync.SynchronizationCredentials;
+import de.danoeh.antennapod.core.service.download.AntennapodHttpClient;
+import de.danoeh.antennapod.net.sync.gpoddernet.GpodnetService;
+import de.danoeh.antennapod.net.sync.gpoddernet.GpodnetServiceException;
+import de.danoeh.antennapod.net.sync.gpoddernet.model.GpodnetPodcast;
+import io.reactivex.Single;
+import io.reactivex.SingleOnSubscribe;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.schedulers.Schedulers;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GpodnetPodcastSearcher implements PodcastSearcher {
+    public Single<List<PodcastSearchResult>> search(String query) {
+        return Single.create((SingleOnSubscribe<List<PodcastSearchResult>>) subscriber -> {
+            try {
+                GpodnetService service = new GpodnetService(AntennapodHttpClient.getHttpClient(),
+                        SynchronizationCredentials.getHosturl(), SynchronizationCredentials.getDeviceID(),
+                        SynchronizationCredentials.getUsername(), SynchronizationCredentials.getPassword());
+                List<GpodnetPodcast> gpodnetPodcasts = service.searchPodcasts(query, 0);
+                List<PodcastSearchResult> results = new ArrayList<>();
+                for (GpodnetPodcast podcast : gpodnetPodcasts) {
+                    results.add(PodcastSearchResult.fromGpodder(podcast));
+                }
+                subscriber.onSuccess(results);
+            } catch (GpodnetServiceException e) {
+                e.printStackTrace();
+                subscriber.onError(e);
+            }
+        })
+        .subscribeOn(Schedulers.io())
+        .observeOn(AndroidSchedulers.mainThread());
+    }
+
+    @Override
+    public Single<String> lookupUrl(String url) {
+        return Single.just(url);
+    }
+
+    @Override
+    public boolean urlNeedsLookup(String url) {
+        return false;
+    }
+
+    @Override
+    public String getName() {
+        return "Gpodder.net";
+    }
+}
diff --git a/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/ItunesPodcastSearcher.java b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/ItunesPodcastSearcher.java
new file mode 100644
index 000000000..b2ac1766c
--- /dev/null
+++ b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/ItunesPodcastSearcher.java
@@ -0,0 +1,116 @@
+package de.danoeh.antennapod.net.discovery;
+
+import de.danoeh.antennapod.core.feed.FeedUrlNotFoundException;
+import de.danoeh.antennapod.core.service.download.AntennapodHttpClient;
+import io.reactivex.Single;
+import io.reactivex.SingleOnSubscribe;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.schedulers.Schedulers;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ItunesPodcastSearcher implements PodcastSearcher {
+    private static final String ITUNES_API_URL = "https://itunes.apple.com/search?media=podcast&term=%s";
+    private static final String PATTERN_BY_ID = ".*/podcasts\\.apple\\.com/.*/podcast/.*/id(\\d+).*";
+
+    public ItunesPodcastSearcher() {
+    }
+
+    @Override
+    public Single<List<PodcastSearchResult>> search(String query) {
+        return Single.create((SingleOnSubscribe<List<PodcastSearchResult>>) subscriber -> {
+            String encodedQuery;
+            try {
+                encodedQuery = URLEncoder.encode(query, "UTF-8");
+            } catch (UnsupportedEncodingException e) {
+                // this won't ever be thrown
+                encodedQuery = query;
+            }
+
+            String formattedUrl = String.format(ITUNES_API_URL, encodedQuery);
+
+            OkHttpClient client = AntennapodHttpClient.getHttpClient();
+            Request.Builder httpReq = new Request.Builder()
+                    .url(formattedUrl);
+            List<PodcastSearchResult> podcasts = new ArrayList<>();
+            try {
+                Response response = client.newCall(httpReq.build()).execute();
+
+                if (response.isSuccessful()) {
+                    String resultString = response.body().string();
+                    JSONObject result = new JSONObject(resultString);
+                    JSONArray j = result.getJSONArray("results");
+
+                    for (int i = 0; i < j.length(); i++) {
+                        JSONObject podcastJson = j.getJSONObject(i);
+                        PodcastSearchResult podcast = PodcastSearchResult.fromItunes(podcastJson);
+                        if (podcast.feedUrl != null) {
+                            podcasts.add(podcast);
+                        }
+                    }
+                } else {
+                    subscriber.onError(new IOException(response.toString()));
+                }
+            } catch (IOException | JSONException e) {
+                subscriber.onError(e);
+            }
+            subscriber.onSuccess(podcasts);
+        })
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread());
+    }
+
+    @Override
+    public Single<String> lookupUrl(String url) {
+        Pattern pattern = Pattern.compile(PATTERN_BY_ID);
+        Matcher matcher = pattern.matcher(url);
+        final String lookupUrl = matcher.find() ? ("https://itunes.apple.com/lookup?id=" + matcher.group(1)) : url;
+        return Single.create(emitter -> {
+            OkHttpClient client = AntennapodHttpClient.getHttpClient();
+            Request.Builder httpReq = new Request.Builder().url(lookupUrl);
+            try {
+                Response response = client.newCall(httpReq.build()).execute();
+                if (response.isSuccessful()) {
+                    String resultString = response.body().string();
+                    JSONObject result = new JSONObject(resultString);
+                    JSONObject results = result.getJSONArray("results").getJSONObject(0);
+                    String feedUrlName = "feedUrl";
+                    if (!results.has(feedUrlName)) {
+                        String artistName = results.getString("artistName");
+                        String trackName = results.getString("trackName");
+                        emitter.onError(new FeedUrlNotFoundException(artistName, trackName));
+                        return;
+                    }
+                    String feedUrl = results.getString(feedUrlName);
+                    emitter.onSuccess(feedUrl);
+                } else {
+                    emitter.onError(new IOException(response.toString()));
+                }
+            } catch (IOException | JSONException e) {
+                emitter.onError(e);
+            }
+        });
+    }
+
+    @Override
+    public boolean urlNeedsLookup(String url) {
+        return url.contains("itunes.apple.com") || url.matches(PATTERN_BY_ID);
+    }
+
+    @Override
+    public String getName() {
+        return "iTunes";
+    }
+}
diff --git a/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/ItunesTopListLoader.java b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/ItunesTopListLoader.java
new file mode 100644
index 000000000..827a3202f
--- /dev/null
+++ b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/ItunesTopListLoader.java
@@ -0,0 +1,102 @@
+package de.danoeh.antennapod.net.discovery;
+
+import android.content.Context;
+import android.util.Log;
+
+import de.danoeh.antennapod.core.service.download.AntennapodHttpClient;
+import io.reactivex.Single;
+import io.reactivex.SingleOnSubscribe;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.schedulers.Schedulers;
+import okhttp3.CacheControl;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.TimeUnit;
+
+public class ItunesTopListLoader {
+    private static final String TAG = "ITunesTopListLoader";
+    private final Context context;
+    public static final String PREF_KEY_COUNTRY_CODE = "country_code";
+    public static final String PREFS = "CountryRegionPrefs";
+    public static final String DISCOVER_HIDE_FAKE_COUNTRY_CODE = "00";
+    public static final String COUNTRY_CODE_UNSET = "99";
+
+    public ItunesTopListLoader(Context context) {
+        this.context = context;
+    }
+
+    public Single<List<PodcastSearchResult>> loadToplist(String country, int limit) {
+        return Single.create((SingleOnSubscribe<List<PodcastSearchResult>>) emitter -> {
+            OkHttpClient client = AntennapodHttpClient.getHttpClient();
+            String feedString;
+            String loadCountry = country;
+            if (COUNTRY_CODE_UNSET.equals(country)) {
+                loadCountry = Locale.getDefault().getCountry();
+            }
+            try {
+                feedString = getTopListFeed(client, loadCountry, limit);
+            } catch (IOException e) {
+                if (COUNTRY_CODE_UNSET.equals(country)) {
+                    feedString = getTopListFeed(client, "US", limit);
+                } else {
+                    emitter.onError(e);
+                    return;
+                }
+            }
+
+            List<PodcastSearchResult> podcasts = parseFeed(feedString);
+            emitter.onSuccess(podcasts);
+        })
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread());
+    }
+
+    private String getTopListFeed(OkHttpClient client, String country, int limit) throws IOException {
+        String url = "https://itunes.apple.com/%s/rss/toppodcasts/limit=" + limit + "/explicit=true/json";
+        Log.d(TAG, "Feed URL " + String.format(url, country));
+        Request.Builder httpReq = new Request.Builder()
+                .cacheControl(new CacheControl.Builder().maxStale(1, TimeUnit.DAYS).build())
+                .url(String.format(url, country));
+
+        try (Response response = client.newCall(httpReq.build()).execute()) {
+            if (response.isSuccessful()) {
+                return response.body().string();
+            }
+            if (response.code() == 400) {
+                throw new IOException("iTunes does not have data for the selected country.");
+            }
+            String prefix = context.getString(R.string.error_msg_prefix);
+            throw new IOException(prefix + response);
+        }
+    }
+
+    private List<PodcastSearchResult> parseFeed(String jsonString) throws JSONException {
+        JSONObject result = new JSONObject(jsonString);
+        JSONObject feed;
+        JSONArray entries;
+        try {
+            feed = result.getJSONObject("feed");
+            entries = feed.getJSONArray("entry");
+        } catch (JSONException e) {
+            return new ArrayList<>();
+        }
+
+        List<PodcastSearchResult> results = new ArrayList<>();
+        for (int i = 0; i < entries.length(); i++) {
+            JSONObject json = entries.getJSONObject(i);
+            results.add(PodcastSearchResult.fromItunesToplist(json));
+        }
+
+        return results;
+    }
+
+}
diff --git a/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastIndexPodcastSearcher.java b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastIndexPodcastSearcher.java
new file mode 100644
index 000000000..4645aaf62
--- /dev/null
+++ b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastIndexPodcastSearcher.java
@@ -0,0 +1,126 @@
+package de.danoeh.antennapod.net.discovery;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.TimeZone;
+
+import de.danoeh.antennapod.net.discovery.BuildConfig;
+import de.danoeh.antennapod.core.ClientConfig;
+import de.danoeh.antennapod.core.service.download.AntennapodHttpClient;
+import io.reactivex.Single;
+import io.reactivex.SingleOnSubscribe;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.schedulers.Schedulers;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+
+public class PodcastIndexPodcastSearcher implements PodcastSearcher {
+    private static final String PODCASTINDEX_API_URL = "https://api.podcastindex.org/api/1.0/search/byterm?q=%s";
+
+    public PodcastIndexPodcastSearcher() {
+    }
+
+    @Override
+    public Single<List<PodcastSearchResult>> search(String query) {
+        return Single.create((SingleOnSubscribe<List<PodcastSearchResult>>) subscriber -> {
+
+            Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
+            calendar.clear();
+            Date now = new Date();
+            calendar.setTime(now);
+            long secondsSinceEpoch = calendar.getTimeInMillis() / 1000L;
+            String apiHeaderTime = String.valueOf(secondsSinceEpoch);
+            String data4Hash = BuildConfig.PODCASTINDEX_API_KEY + BuildConfig.PODCASTINDEX_API_SECRET + apiHeaderTime;
+            String hashString = sha1(data4Hash);
+
+            String encodedQuery;
+            try {
+                encodedQuery = URLEncoder.encode(query, "UTF-8");
+            } catch (UnsupportedEncodingException e) {
+                // this won't ever be thrown
+                encodedQuery = query;
+            }
+
+            String formattedUrl = String.format(PODCASTINDEX_API_URL, encodedQuery);
+
+            OkHttpClient client = AntennapodHttpClient.getHttpClient();
+            Request.Builder httpReq = new Request.Builder()
+                    .addHeader("X-Auth-Date", apiHeaderTime)
+                    .addHeader("X-Auth-Key", BuildConfig.PODCASTINDEX_API_KEY)
+                    .addHeader("Authorization", hashString)
+                    .addHeader("User-Agent", ClientConfig.USER_AGENT)
+                    .url(formattedUrl);
+            List<PodcastSearchResult> podcasts = new ArrayList<>();
+            try {
+                Response response = client.newCall(httpReq.build()).execute();
+
+                if (response.isSuccessful()) {
+                    String resultString = response.body().string();
+                    JSONObject result = new JSONObject(resultString);
+                    JSONArray j = result.getJSONArray("feeds");
+
+                    for (int i = 0; i < j.length(); i++) {
+                        JSONObject podcastJson = j.getJSONObject(i);
+                        PodcastSearchResult podcast = PodcastSearchResult.fromPodcastIndex(podcastJson);
+                        if (podcast.feedUrl != null) {
+                            podcasts.add(podcast);
+                        }
+                    }
+                } else {
+                    subscriber.onError(new IOException(response.toString()));
+                }
+            } catch (IOException | JSONException e) {
+                subscriber.onError(e);
+            }
+            subscriber.onSuccess(podcasts);
+        })
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread());
+    }
+
+    @Override
+    public Single<String> lookupUrl(String url) {
+        return Single.just(url);
+    }
+
+    @Override
+    public boolean urlNeedsLookup(String url) {
+        return false;
+    }
+
+    @Override
+    public String getName() {
+        return "Podcastindex.org";
+    }
+
+    private static String sha1(String clearString) {
+        try {
+            MessageDigest messageDigest = MessageDigest.getInstance("SHA-1");
+            messageDigest.update(clearString.getBytes("UTF-8"));
+            return toHex(messageDigest.digest());
+        } catch (Exception ignored) {
+            ignored.printStackTrace();
+            return null;
+        }
+    }
+
+    private static String toHex(byte[] bytes) {
+        StringBuilder buffer = new StringBuilder();
+        for (byte b : bytes) {
+            buffer.append(String.format(Locale.getDefault(), "%02x", b));
+        }
+        return buffer.toString();
+    }
+}
diff --git a/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastSearchResult.java b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastSearchResult.java
new file mode 100644
index 000000000..b3f352334
--- /dev/null
+++ b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastSearchResult.java
@@ -0,0 +1,110 @@
+package de.danoeh.antennapod.net.discovery;
+
+import androidx.annotation.Nullable;
+import de.danoeh.antennapod.net.sync.gpoddernet.model.GpodnetPodcast;
+import de.mfietz.fyydlin.SearchHit;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class PodcastSearchResult {
+
+    /**
+     * The name of the podcast
+     */
+    public final String title;
+
+    /**
+     * URL of the podcast image
+     */
+    @Nullable
+    public final String imageUrl;
+    /**
+     * URL of the podcast feed
+     */
+    @Nullable
+    public final String feedUrl;
+
+    /**
+     * artistName of the podcast feed
+     */
+    @Nullable
+    public final String author;
+
+
+    private PodcastSearchResult(String title, @Nullable String imageUrl, @Nullable String feedUrl, @Nullable String author) {
+        this.title = title;
+        this.imageUrl = imageUrl;
+        this.feedUrl = feedUrl;
+        this.author = author;
+    }
+
+    public static PodcastSearchResult dummy() {
+        return new PodcastSearchResult("", "", "", "");
+    }
+
+    /**
+     * Constructs a Podcast instance from a iTunes search result
+     *
+     * @param json object holding the podcast information
+     * @throws JSONException
+     */
+    public static PodcastSearchResult fromItunes(JSONObject json) {
+        String title = json.optString("collectionName", "");
+        String imageUrl = json.optString("artworkUrl100", null);
+        String feedUrl = json.optString("feedUrl", null);
+        String author = json.optString("artistName", null);
+        return new PodcastSearchResult(title, imageUrl, feedUrl, author);
+    }
+
+    /**
+     * Constructs a Podcast instance from iTunes toplist entry
+     *
+     * @param json object holding the podcast information
+     * @throws JSONException
+     */
+    public static PodcastSearchResult fromItunesToplist(JSONObject json) throws JSONException {
+        String title = json.getJSONObject("title").getString("label");
+        String imageUrl = null;
+        JSONArray images =  json.getJSONArray("im:image");
+        for(int i=0; imageUrl == null && i < images.length(); i++) {
+            JSONObject image = images.getJSONObject(i);
+            String height = image.getJSONObject("attributes").getString("height");
+            if(Integer.parseInt(height) >= 100) {
+                imageUrl = image.getString("label");
+            }
+        }
+        String feedUrl = "https://itunes.apple.com/lookup?id=" +
+                json.getJSONObject("id").getJSONObject("attributes").getString("im:id");
+
+        String author = null;
+        try {
+            author = json.getJSONObject("im:artist").getString("label");
+        } catch (Exception e) {
+            // Some feeds have empty artist
+        }
+        return new PodcastSearchResult(title, imageUrl, feedUrl, author);
+    }
+
+    public static PodcastSearchResult fromFyyd(SearchHit searchHit) {
+        return new PodcastSearchResult(searchHit.getTitle(),
+                                       searchHit.getThumbImageURL(),
+                                       searchHit.getXmlUrl(),
+                                       searchHit.getAuthor());
+    }
+
+    public static PodcastSearchResult fromGpodder(GpodnetPodcast searchHit) {
+        return new PodcastSearchResult(searchHit.getTitle(),
+                                       searchHit.getLogoUrl(),
+                                       searchHit.getUrl(),
+                                       searchHit.getAuthor());
+    }
+
+    public static PodcastSearchResult fromPodcastIndex(JSONObject json) {
+        String title = json.optString("title", "");
+        String imageUrl = json.optString("image", null);
+        String feedUrl = json.optString("url", null);
+        String author = json.optString("author", null);
+        return new PodcastSearchResult(title, imageUrl, feedUrl, author);
+    }
+}
diff --git a/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastSearcher.java b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastSearcher.java
new file mode 100644
index 000000000..76edbf843
--- /dev/null
+++ b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastSearcher.java
@@ -0,0 +1,14 @@
+package de.danoeh.antennapod.net.discovery;
+
+import io.reactivex.Single;
+import java.util.List;
+
+public interface PodcastSearcher {
+    Single<List<PodcastSearchResult>> search(String query);
+
+    Single<String> lookupUrl(String resultUrl);
+
+    boolean urlNeedsLookup(String resultUrl);
+
+    String getName();
+}
diff --git a/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastSearcherRegistry.java b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastSearcherRegistry.java
new file mode 100644
index 000000000..c7892bd09
--- /dev/null
+++ b/net/discovery/src/main/java/de/danoeh/antennapod/net/discovery/PodcastSearcherRegistry.java
@@ -0,0 +1,55 @@
+package de.danoeh.antennapod.net.discovery;
+
+import io.reactivex.Single;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PodcastSearcherRegistry {
+    private static List<SearcherInfo> searchProviders;
+
+    private PodcastSearcherRegistry() {
+    }
+
+    public static synchronized List<SearcherInfo> getSearchProviders() {
+        if (searchProviders == null) {
+            searchProviders = new ArrayList<>();
+            searchProviders.add(new SearcherInfo(new CombinedSearcher(), 1.0f));
+            searchProviders.add(new SearcherInfo(new GpodnetPodcastSearcher(), 0.0f));
+            searchProviders.add(new SearcherInfo(new FyydPodcastSearcher(), 1.0f));
+            searchProviders.add(new SearcherInfo(new ItunesPodcastSearcher(), 1.0f));
+            searchProviders.add(new SearcherInfo(new PodcastIndexPodcastSearcher(), 1.0f));
+        }
+        return searchProviders;
+    }
+
+    public static Single<String> lookupUrl(String url) {
+        for (PodcastSearcherRegistry.SearcherInfo searchProviderInfo : getSearchProviders()) {
+            if (searchProviderInfo.searcher.getClass() != CombinedSearcher.class
+                    && searchProviderInfo.searcher.urlNeedsLookup(url)) {
+                return searchProviderInfo.searcher.lookupUrl(url);
+            }
+        }
+        return Single.just(url);
+    }
+
+    public static boolean urlNeedsLookup(String url) {
+        for (PodcastSearcherRegistry.SearcherInfo searchProviderInfo : getSearchProviders()) {
+            if (searchProviderInfo.searcher.getClass() != CombinedSearcher.class
+                    && searchProviderInfo.searcher.urlNeedsLookup(url)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static class SearcherInfo {
+        public final PodcastSearcher searcher;
+        public final float weight;
+
+        public SearcherInfo(PodcastSearcher searcher, float weight) {
+            this.searcher = searcher;
+            this.weight = weight;
+        }
+    }
+}