searchfilters: a framework to create sort and content filter objects

Author: evermind-zz

extractor/src/main/java/org/schabi/newpipe/extractor/search/filter/Filter.java

@@ -0,0 +1,33 @@
+package org.schabi.newpipe.extractor.search.filter;
+
+public final class Filter {
+
+    public static final int ITEM_IDENTIFIER_UNKNOWN = -1;
+    private final FilterGroup[] sortGroups;
+    private int size = 0;
+
+    private Filter(final FilterGroup[] sortGroups) {
+        this.sortGroups = sortGroups;
+    }
+
+    public FilterGroup[] getFilterGroups() {
+        return sortGroups;
+    }
+
+    public static class Builder {
+        final Filter filter;
+
+        public Builder(final FilterGroup[] sortGroups) {
+            filter = new Filter(sortGroups);
+        }
+
+        public Builder setNoOfFilters(final int noOfFilters) {
+            filter.size = noOfFilters;
+            return this;
+        }
+
+        public Filter build() {
+            return filter;
+        }
+    }
+}

extractor/src/main/java/org/schabi/newpipe/extractor/search/filter/FilterGroup.java

@@ -0,0 +1,78 @@
+package org.schabi.newpipe.extractor.search.filter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FilterGroup {
+    public final String groupName;
+    public final FilterItem[] filterItems;
+    public final int identifier;
+    public boolean onlyOneCheckable;
+
+    public FilterGroup(final int identifier, final String groupName,
+                       final boolean onlyOneCheckable,
+                       final FilterItem[] filterItems) {
+        this.identifier = identifier;
+        this.groupName = groupName;
+        this.onlyOneCheckable = onlyOneCheckable;
+        this.filterItems = filterItems;
+    }
+
+    public static class Builder {
+        public final Map<Integer, FilterItem> filtersMap = new HashMap<>();
+        private final Map<String, Integer> filtersSortGroupMap = new HashMap<>();
+        public int noOfSortFilters;
+        public FilterGroup[] filterGroups = null;
+        /**
+         * used to give each added filter an unique identifier
+         */
+        private int identifierIncrement;
+        private int noOfContentFilters;
+
+        public Builder() {
+            this.noOfSortFilters = 0;
+            this.noOfContentFilters = 0;
+            this.identifierIncrement = 0;
+        }
+
+        public int addSortItem(final FilterItem filter) {
+            this.noOfSortFilters++;
+            return addItem(filter);
+        }
+
+        public int addFilterItem(final FilterItem filter) {
+            this.noOfContentFilters++;
+            return addItem(filter);
+        }
+
+        private int addItem(final FilterItem filter) {
+            final FilterItem.Builder filterItemBuilder =
+                    FilterItem.builder(filter);
+            filterItemBuilder.setIdentifier(this.identifierIncrement);
+            filtersMap.put(this.identifierIncrement, filterItemBuilder.build());
+            return this.identifierIncrement++;
+        }
+
+        public int getNoOfSortFilters() {
+            return this.noOfSortFilters;
+        }
+
+        public FilterGroup createSortGroup(final String groupName,
+                                              final boolean onlyOneCheckable,
+                                              final FilterItem[] filterItems) {
+            final int identifier;
+            if (filtersSortGroupMap.containsKey(groupName)) {
+                identifier = filtersSortGroupMap.get(groupName);
+            } else {
+                identifier = this.identifierIncrement++;
+                filtersSortGroupMap.put(groupName, identifier);
+            }
+
+            return new FilterGroup(identifier, groupName, onlyOneCheckable, filterItems);
+        }
+
+        public FilterItem getFilterForId(final int filterId) {
+            return filtersMap.get(filterId);
+        }
+    }
+}

extractor/src/main/java/org/schabi/newpipe/extractor/search/filter/FilterItem.java

@@ -0,0 +1,53 @@
+package org.schabi.newpipe.extractor.search.filter;
+
+public class FilterItem {
+    private final String name;
+    private int identifier;
+    /**
+     * check if a {@link #FilterItem} was build using the {@link Builder}
+     */
+    private boolean isBuild = false;
+
+    public FilterItem(final int identifier, final String name) {
+        this.identifier = identifier;
+        this.name = name;
+    }
+
+    public static Builder builder(final FilterItem filterItem) {
+        return new Builder(filterItem);
+    }
+
+    public int getIdentifier() {
+        return this.identifier;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public static class Builder {
+
+        private final FilterItem filterItem;
+
+        public Builder(final FilterItem filterItem) {
+            this.filterItem = filterItem;
+        }
+
+        public Builder setIdentifier(final int itemIdentifier) {
+            filterItem.identifier = itemIdentifier;
+            return this;
+        }
+
+        public FilterItem build() {
+            if (filterItem.isBuild) {
+                throw new RuntimeException("filter is already build()");
+            }
+            if (filterItem.identifier == Filter.ITEM_IDENTIFIER_UNKNOWN) {
+                throw new RuntimeException("itemIdentifier is not set");
+            }
+
+            filterItem.isBuild = true;
+            return filterItem;
+        }
+    }
+}

extractor/src/main/java/org/schabi/newpipe/extractor/search/filter/SearchFiltersBase.java

@@ -0,0 +1,138 @@
+package org.schabi.newpipe.extractor.search.filter;
+
+import org.schabi.newpipe.extractor.services.youtube.search.filter.YoutubeFilters;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Deriving class must always call {@link SearchFiltersBase#init()} and {@link SearchFiltersBase#build()}
+ * in constructor manually.
+ */
+public abstract class SearchFiltersBase {
+
+    protected final Map<Integer, Filter> sortFilterVariants = new HashMap<>();
+    protected int defaultContentFilterId = Filter.ITEM_IDENTIFIER_UNKNOWN;
+    protected Integer[] contentFilters;
+    protected FilterGroup.Builder builder = new FilterGroup.Builder();
+    protected List<FilterItem> selectedContentFilter = null;
+    protected List<FilterItem> selectedSortFilter;
+    protected Filter contentFiltersVariant;
+    protected List<FilterGroup> contentFiltersList = new LinkedList<>();
+    private Filter allSortFiltersVariant = null;
+
+    /**
+     * Set the user selected sort filters which the user has selected in the UI.
+     *
+     * @param selectedSortFilter list with sort filters identifiers
+     */
+    public void setSelectedSortFilter(final List<FilterItem> selectedSortFilter) {
+        this.selectedSortFilter = selectedSortFilter;
+    }
+
+    /**
+     * Set the selected content filter
+     *
+     * @param selectedContentFilter the name of the content filter
+     */
+    public void setSelectedContentFilter(final List<FilterItem> selectedContentFilter) {
+        this.selectedContentFilter = selectedContentFilter;
+    }
+
+    /**
+     * Evaluate content and sort filters. This method should be run after:
+     * {@link #setSelectedContentFilter(List)} and {@link #setSelectedSortFilter(List)}
+     *
+     * @return the query that should be appended to the searchUrl/whatever
+     */
+    public String evaluateSelectedFilters(final String searchString) {
+        return "";
+    }
+
+    /**
+     * Evaluate content filters. This method should be run after:
+     * {@link #setSelectedContentFilter(List)}
+     *
+     * @return the sortQuery that should be appended to the searchUrl/whatever
+     */
+    public String evaluateSelectedContentFilters() {
+        return "";
+    }
+
+    /**
+     * Evaluate sort filters. This method should be run after:
+     * {@link #setSelectedSortFilter(List)}
+     *
+     * @return the contentQuery that should be appended to the searchUrl/whatever
+     */
+    public String evaluateSelectedSortFilters() {
+        return "";
+    }
+
+    /**
+     * create all 'sort' and 'content filter' items and all 'sort filter variants' in this method.
+     * See eg. {@link YoutubeFilters#init()}
+     */
+    protected abstract void init();
+
+    public Integer[] getAvailableContentFilter() {
+        return contentFilters;
+    }
+
+    protected void build() {
+        final Set<Map.Entry<Integer, Filter>> entrySet =
+                this.sortFilterVariants.entrySet();
+        this.contentFilters = new Integer[entrySet.size()];
+        int count = 0;
+        for (final Map.Entry<Integer, Filter> entry : entrySet) {
+            this.contentFilters[count++] = entry.getKey();
+
+        }
+
+        this.contentFiltersVariant = new Filter.Builder(
+                this.contentFiltersList.toArray(new FilterGroup[0]))
+                .setNoOfFilters(builder.getNoOfSortFilters()).build();
+    }
+
+    /**
+     * Add content Filter SortVariants.
+     * <p>
+     * Calling the method the first time {@variant} will be set
+     * as all variants sortFilter when called {@link #getSortFilters()}
+     *
+     * @param contentFilterId
+     * @param variant
+     */
+    protected void addContentFilterSortVariant(
+            final int contentFilterId,
+            final Filter variant) {
+        if (this.sortFilterVariants.isEmpty()) {
+            this.allSortFiltersVariant = variant;
+        }
+        this.sortFilterVariants.put(contentFilterId, variant);
+    }
+
+    public Filter getContentFilterSortFilterVariant(
+            final int contentFilterName) {
+        return this.sortFilterVariants.get(contentFilterName);
+    }
+
+    public Filter getSortFilters() {
+        return this.allSortFiltersVariant;
+    }
+
+    public Filter getContentFilters() {
+        return this.contentFiltersVariant;
+    }
+
+    public FilterItem getFilterItem(final int filterId) {
+        return builder.getFilterForId(filterId);
+    }
+
+    protected void addContentFilter(final FilterGroup hds) {
+        this.contentFiltersList.add(hds);
+    }
+}