searchfilters: Make SoundcloudSearchQueryHandlerFactory singleton

Author: evermind-zz

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

@@ -50,7 +50,7 @@ public String getBaseUrl() {
 
     @Override
     public SearchQueryHandlerFactory getSearchQHFactory() {
-        return new SoundcloudSearchQueryHandlerFactory();
+        return SoundcloudSearchQueryHandlerFactory.getInstance();
     }
 
     @Override

extractor/src/main/java/org/schabi/newpipe/extractor/services/soundcloud/linkHandler/SoundcloudSearchQueryHandlerFactory.java

@@ -1,14 +1,13 @@
 package org.schabi.newpipe.extractor.services.soundcloud.linkHandler;
 
-import org.schabi.newpipe.extractor.search.filter.Filter;
-import org.schabi.newpipe.extractor.search.filter.FilterItem;
-import org.schabi.newpipe.extractor.services.soundcloud.search.filter.SoundcloudFilters;
-
 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.linkhandler.SearchQueryHandlerFactory;
+import org.schabi.newpipe.extractor.search.filter.FilterContainer;
+import org.schabi.newpipe.extractor.search.filter.FilterItem;
 import org.schabi.newpipe.extractor.services.soundcloud.SoundcloudParsingHelper;
+import org.schabi.newpipe.extractor.services.soundcloud.search.filter.SoundcloudFilters;
 
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
@@ -21,9 +20,17 @@
 public class SoundcloudSearchQueryHandlerFactory extends SearchQueryHandlerFactory {
 
     public static final int ITEMS_PER_PAGE = 10;
+    private static SoundcloudSearchQueryHandlerFactory instance = null;
 
     private final SoundcloudFilters searchFilters = new SoundcloudFilters();
 
+    public static synchronized SoundcloudSearchQueryHandlerFactory getInstance() {
+        if (instance == null) {
+            instance = new SoundcloudSearchQueryHandlerFactory();
+        }
+        return instance;
+    }
+
     @Override
     public String getUrl(final String id,
                          final List<FilterItem> selectedContentFilter,
@@ -53,17 +60,12 @@ public String getUrl(final String id,
     }
 
     @Override
-    public Filter getAvailableContentFilter() {
+    public FilterContainer getAvailableContentFilter() {
         return searchFilters.getContentFilters();
     }
 
     @Override
-    public Filter getAvailableSortFilter() {
-        return searchFilters.getSortFilters();
-    }
-
-    @Override
-    public Filter getContentFilterSortFilterVariant(final int contentFilterId) {
+    public FilterContainer getContentFilterSortFilterVariant(final int contentFilterId) {
         return searchFilters.getContentFilterSortFilterVariant(contentFilterId);
     }
 

extractor/src/main/java/org/schabi/newpipe/extractor/services/soundcloud/search/filter/SoundcloudFilters.java

@@ -1,125 +1,149 @@
+// Created by evermind-zz 2022, licensed GNU GPL version 3 or later -->
+
 package org.schabi.newpipe.extractor.services.soundcloud.search.filter;
 
-import org.schabi.newpipe.extractor.search.filter.Filter;
+import org.schabi.newpipe.extractor.search.filter.FilterContainer;
 import org.schabi.newpipe.extractor.search.filter.FilterGroup;
 import org.schabi.newpipe.extractor.search.filter.FilterItem;
 import org.schabi.newpipe.extractor.search.filter.SearchFiltersBase;
 
 public final class SoundcloudFilters extends SearchFiltersBase {
 
+    public static final int ID_CF_MAIN_GRP = 0;
+    public static final int ID_CF_MAIN_ALL = 1;
+    public static final int ID_CF_MAIN_TRACKS = 2;
+    public static final int ID_CF_MAIN_USERS = 3;
+    public static final int ID_CF_MAIN_PLAYLISTS = 4;
+    public static final int ID_SF_DATE_GRP = 5;
+    public static final int ID_SF_DATE_ALL = 6;
+    public static final int ID_SF_DATE_LAST_HOUR = 7;
+    public static final int ID_SF_DATE_LAST_DAY = 8;
+    public static final int ID_SF_DATE_LAST_WEEK = 9;
+    public static final int ID_SF_DATE_LAST_MONTH = 10;
+    public static final int ID_SF_DATE_LAST_YEAR = 11;
+    public static final int ID_SF_DURATION_GRP = 12;
+    public static final int ID_SF_DURATION_ALL = 13;
+    public static final int ID_SF_DURATION_SHORT = 14;
+    public static final int ID_SF_DURATION_MEDIUM = 15;
+    public static final int ID_SF_DURATION_LONG = 16;
+    public static final int ID_SF_DURATION_EPIC = 17;
+    public static final int ID_SF_LICENSE_GRP = 18;
+    public static final int ID_SF_LICENSE_ALL = 19;
+    public static final int ID_SF_LICENSE_COMMERCE = 20;
+
     public static final String TRACKS = "tracks";
     public static final String USERS = "users";
     public static final String PLAYLISTS = "playlists";
     public static final String ALL = "all";
 
-    public SoundcloudFilters() {
-        init();
-        build();
-    }
-
     @Override
     public String evaluateSelectedContentFilters() {
         if (selectedContentFilter != null && !selectedContentFilter.isEmpty()) {
-            final SoundcloudContentFilterItem contentItem =
+            final SoundcloudContentFilterItem contentFilter =
                     // we assume there is just one content filter
                     (SoundcloudContentFilterItem) selectedContentFilter.get(0);
-            return contentItem.urlEndpoint;
+            if (null != contentFilter) {
+                return contentFilter.urlEndpoint;
+            }
         }
         return "";
     }
 
     @Override
     protected void init() {
         /* content filters */
-        final int contentFilterAll = builder.addFilterItem(
-                new SoundcloudContentFilterItem(ALL, ""));
-        final int contentFilterTracks = builder.addFilterItem(
-                new SoundcloudContentFilterItem(TRACKS, "/tracks"));
-        final int contentFilterUsers = builder.addFilterItem(
-                new SoundcloudContentFilterItem(USERS, "/users"));
-        final int contentFilterPlaylists = builder.addFilterItem(
-                new SoundcloudContentFilterItem(PLAYLISTS, "/playlists"));
+        groupsFactory.addFilterItem(new SoundcloudContentFilterItem(
+                ID_CF_MAIN_ALL, ALL, ""));
+        groupsFactory.addFilterItem(new SoundcloudContentFilterItem(
+                ID_CF_MAIN_TRACKS, TRACKS, "/tracks"));
+        groupsFactory.addFilterItem(new SoundcloudContentFilterItem(
+                ID_CF_MAIN_USERS, USERS, "/users"));
+        groupsFactory.addFilterItem(new SoundcloudContentFilterItem(
+                ID_CF_MAIN_PLAYLISTS, PLAYLISTS, "/playlists"));
 
-        /* set default content filter */
-
-        // 'ALL' this is the default search content filter.
-        this.defaultContentFilterId = contentFilterAll;
-
-
-        /* content filters with sort filters */
-        addContentFilter(builder.createSortGroup(null, true, new FilterItem[]{
-                builder.getFilterForId(contentFilterAll),
-                builder.getFilterForId(contentFilterTracks),
-                builder.getFilterForId(contentFilterUsers),
-                builder.getFilterForId(contentFilterPlaylists),
-        }));
 
+        /* Sort filters */
         /* 'Date' filter items */
-        final int filterIdDateAll = builder.addSortItem(
-                new SoundcloudSortFilterItem("all", ""));
-        final int filterIdDateLastHour = builder.addSortItem(
-                new SoundcloudSortFilterItem("Past hour", "filter.created_at=last_hour"));
-        final int filterIdDateLastDay = builder.addSortItem(
-                new SoundcloudSortFilterItem("Past day", "filter.created_at=last_day"));
-        final int filterIdDateLastWeek = builder.addSortItem(
-                new SoundcloudSortFilterItem("Past week", "filter.created_at=last_week"));
-        final int filterIdDateLastMonth = builder.addSortItem(
-                new SoundcloudSortFilterItem("Past month", "filter.created_at=last_month"));
-        final int filterIdDateLastYear = builder.addSortItem(
-                new SoundcloudSortFilterItem("Past year", "filter.created_at=last_year"));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_DATE_ALL, "all", ""));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_DATE_LAST_HOUR, "Past hour", "filter.created_at=last_hour"));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_DATE_LAST_DAY, "Past day", "filter.created_at=last_day"));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_DATE_LAST_WEEK, "Past week", "filter.created_at=last_week"));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_DATE_LAST_MONTH, "Past month", "filter.created_at=last_month"));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_DATE_LAST_YEAR, "Past year", "filter.created_at=last_year"));
 
         /* duration' filter items */
-        final int filterIdDurationAll = builder.addSortItem(
-                new SoundcloudSortFilterItem("all", ""));
-        final int filterIdDurationShort = builder.addSortItem(
-                new SoundcloudSortFilterItem("< 2 min", "filter.duration=short"));
-        final int filterIdDurationMedium = builder.addSortItem(
-                new SoundcloudSortFilterItem("2-10 min", "filter.duration=medium"));
-        final int filterIdDurationLong = builder.addSortItem(
-                new SoundcloudSortFilterItem("10-30 min", "filter.duration=long"));
-        final int filterIdDurationEpic = builder.addSortItem(
-                new SoundcloudSortFilterItem("> 30 min", "filter.duration=epic"));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_DURATION_ALL, "all", ""));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_DURATION_SHORT, "< 2 min", "filter.duration=short"));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_DURATION_MEDIUM, "2-10 min", "filter.duration=medium"));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_DURATION_LONG, "10-30 min", "filter.duration=long"));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_DURATION_EPIC, "> 30 min", "filter.duration=epic"));
 
         /* license */
-        final int filterIdLicenseAll = builder.addSortItem(
-                new SoundcloudSortFilterItem("all", ""));
-        final int filterIdLicenseCommerce = builder.addSortItem(
-                new SoundcloudSortFilterItem("To modify commercially",
-                        "filter.license=to_modify_commercially"));
-
-        addContentFilterSortVariant(contentFilterTracks,
-                new Filter.Builder(new FilterGroup[]{
-                        builder.createSortGroup("Sort by", true, new FilterItem[]{
-                                builder.getFilterForId(filterIdDateAll),
-                                builder.getFilterForId(filterIdDateLastHour),
-                                builder.getFilterForId(filterIdDateLastDay),
-                                builder.getFilterForId(filterIdDateLastWeek),
-                                builder.getFilterForId(filterIdDateLastMonth),
-                                builder.getFilterForId(filterIdDateLastYear),
-                        }),
-                        builder.createSortGroup("Length", true, new FilterItem[]{
-                                builder.getFilterForId(filterIdDurationAll),
-                                builder.getFilterForId(filterIdDurationShort),
-                                builder.getFilterForId(filterIdDurationMedium),
-                                builder.getFilterForId(filterIdDurationLong),
-                                builder.getFilterForId(filterIdDurationEpic),
-                        }),
-                        builder.createSortGroup("License", true, new FilterItem[]{
-                                builder.getFilterForId(filterIdLicenseAll),
-                                builder.getFilterForId(filterIdLicenseCommerce),
-                        }),
-                }).build());
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_LICENSE_ALL, "all", ""));
+        groupsFactory.addFilterItem(new SoundcloudSortFilterItem(
+                ID_SF_LICENSE_COMMERCE, "To modify commercially",
+                "filter.license=to_modify_commercially"));
+
+        final FilterContainer allMainCFGrpSortFilters = new FilterContainer(new FilterGroup[]{
+                groupsFactory.createFilterGroup(ID_SF_DATE_GRP, "Sort by", true,
+                        ID_SF_DATE_ALL, new FilterItem[]{
+                                groupsFactory.getFilterForId(ID_SF_DATE_ALL),
+                                groupsFactory.getFilterForId(ID_SF_DATE_LAST_HOUR),
+                                groupsFactory.getFilterForId(ID_SF_DATE_LAST_DAY),
+                                groupsFactory.getFilterForId(ID_SF_DATE_LAST_WEEK),
+                                groupsFactory.getFilterForId(ID_SF_DATE_LAST_MONTH),
+                                groupsFactory.getFilterForId(ID_SF_DATE_LAST_YEAR),
+                        }, null),
+                groupsFactory.createFilterGroup(ID_SF_DURATION_GRP, "Length", true,
+                        ID_SF_DURATION_ALL, new FilterItem[]{
+                                groupsFactory.getFilterForId(ID_SF_DURATION_ALL),
+                                groupsFactory.getFilterForId(ID_SF_DURATION_SHORT),
+                                groupsFactory.getFilterForId(ID_SF_DURATION_MEDIUM),
+                                groupsFactory.getFilterForId(ID_SF_DURATION_LONG),
+                                groupsFactory.getFilterForId(ID_SF_DURATION_EPIC),
+                        }, null),
+                groupsFactory.createFilterGroup(ID_SF_LICENSE_GRP, "License", true,
+                        ID_SF_LICENSE_ALL, new FilterItem[]{
+                                groupsFactory.getFilterForId(ID_SF_LICENSE_ALL),
+                                groupsFactory.getFilterForId(ID_SF_LICENSE_COMMERCE),
+                        }, null),
+        });
+
+        /* content filters */
+        addContentFilterGroup(groupsFactory.createFilterGroup(ID_CF_MAIN_GRP, null, true,
+                ID_CF_MAIN_ALL, new FilterItem[]{
+                        groupsFactory.getFilterForId(ID_CF_MAIN_ALL),
+                        groupsFactory.getFilterForId(ID_CF_MAIN_TRACKS),
+                        groupsFactory.getFilterForId(ID_CF_MAIN_USERS),
+                        groupsFactory.getFilterForId(ID_CF_MAIN_PLAYLISTS),
+                }, allMainCFGrpSortFilters));
+
+        addContentFilterSortVariant(ID_CF_MAIN_TRACKS, allMainCFGrpSortFilters);
     }
 
     @Override
     public String evaluateSelectedSortFilters() {
         final StringBuilder sortQuery = new StringBuilder();
-        for (final FilterItem item : selectedSortFilter) {
-            final SoundcloudSortFilterItem sortItem =
-                    (SoundcloudSortFilterItem) item;
-            if (sortItem != null) {
-                if (!sortItem.query.isEmpty()) {
-                    sortQuery.append("&").append(sortItem.query);
+        if (selectedSortFilter != null) {
+            for (final FilterItem item : selectedSortFilter) {
+                final SoundcloudSortFilterItem sortItem =
+                        (SoundcloudSortFilterItem) item;
+                if (sortItem != null) {
+                    if (!sortItem.query.isEmpty()) {
+                        sortQuery.append("&").append(sortItem.query);
+                    }
                 }
             }
         }
@@ -130,17 +154,18 @@ public String evaluateSelectedSortFilters() {
     private static class SoundcloudSortFilterItem extends FilterItem {
         private final String query;
 
-        SoundcloudSortFilterItem(final String name, final String query) {
-            super(Filter.ITEM_IDENTIFIER_UNKNOWN, name);
+        SoundcloudSortFilterItem(final int identifier, final String name, final String query) {
+            super(identifier, name);
             this.query = query;
         }
     }
 
     private static final class SoundcloudContentFilterItem extends FilterItem {
         private final String urlEndpoint;
 
-        private SoundcloudContentFilterItem(final String name, final String urlEndpoint) {
-            super(Filter.ITEM_IDENTIFIER_UNKNOWN, name);
+        private SoundcloudContentFilterItem(final int identifier, final String name,
+                                            final String urlEndpoint) {
+            super(identifier, name);
             this.urlEndpoint = urlEndpoint;
         }
     }