Makes search work.

Android/app/src/main/java/com/majinnaibu/monstercards/ui/search/SearchFragment.java

@@ -1,34 +1,49 @@
 package com.majinnaibu.monstercards.ui.search;
 
+import android.content.Context;
 import android.os.Bundle;
 import android.text.Editable;
 import android.text.TextWatcher;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.widget.EditText;
 import android.widget.TextView;
 
 import androidx.annotation.NonNull;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.ViewModelProvider;
+import androidx.navigation.NavDirections;
+import androidx.navigation.Navigation;
+import androidx.recyclerview.widget.DividerItemDecoration;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
 
-import com.majinnaibu.monstercards.R;
+import com.majinnaibu.monstercards.databinding.FragmentSearchBinding;
-import com.majinnaibu.monstercards.data.MonsterRepository;
+import com.majinnaibu.monstercards.models.Monster;
 import com.majinnaibu.monstercards.ui.shared.MCFragment;
+import com.majinnaibu.monstercards.utils.Logger;
+
+import java.util.List;
 
 public class SearchFragment extends MCFragment {
+    private SearchViewModel mViewModel;
+    private ViewHolder mHolder;
+    private SearchResultsRecyclerViewAdapter mAdapter;
 
-    public View onCreateView(@NonNull LayoutInflater inflater,
+    @Override
-                             ViewGroup container, Bundle savedInstanceState) {
+    public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
-        View root = inflater.inflate(R.layout.fragment_search, container, false);
+        mViewModel = new ViewModelProvider(this).get(SearchViewModel.class);
-        MonsterRepository repository = this.getMonsterRepository();
+        FragmentSearchBinding binding = FragmentSearchBinding.inflate(inflater, container, false);
-        SearchResultsRecyclerViewAdapter adapter = new SearchResultsRecyclerViewAdapter(repository, null);
+        mHolder = new ViewHolder(binding);
-        final RecyclerView recyclerView = root.findViewById(R.id.monster_list);
+        // TODO: set the title with setTitle(...)
-        assert recyclerView != null;
+        setupMonsterList(binding.monsterList);
-        setupRecyclerView(recyclerView, adapter);
+        setupFilterBox(binding.searchQuery);
+        return binding.getRoot();
+    }
 
-        final TextView textView = root.findViewById(R.id.search_query);
+    private void setupFilterBox(@NonNull TextView textBox) {
-        textView.addTextChangedListener(new TextWatcher() {
+        textBox.addTextChangedListener(new TextWatcher() {
             @Override
             public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
             }
@@ -39,15 +54,42 @@ public class SearchFragment extends MCFragment {
 
             @Override
             public void afterTextChanged(Editable editable) {
-                adapter.doSearch(textView.getText().toString());
+                mViewModel.setFilterText(textBox.getText().toString());
             }
         });
-
-        return root;
     }
 
-    private void setupRecyclerView(@NonNull RecyclerView recyclerView, @NonNull SearchResultsRecyclerViewAdapter adapter) {
+    private void setupMonsterList(@NonNull RecyclerView recyclerView) {
-        recyclerView.setAdapter(adapter);
+        Context context = requireContext();
-        recyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
+        LinearLayoutManager layoutManager = new LinearLayoutManager(context);
+        recyclerView.setLayoutManager(layoutManager);
+
+        LiveData<List<Monster>> monsterData = mViewModel.getMatchedMonsters();
+        mAdapter = new SearchResultsRecyclerViewAdapter(this::navigateToMonsterDetail);
+        if (monsterData != null) {
+            monsterData.observe(getViewLifecycleOwner(), monsters -> mAdapter.submitList(monsters));
+        }
+        recyclerView.setAdapter(mAdapter);
+        DividerItemDecoration dividerItemDecoration = new DividerItemDecoration(context, layoutManager.getOrientation());
+        recyclerView.addItemDecoration(dividerItemDecoration);
+    }
+
+    public void navigateToMonsterDetail(Monster monster) {
+        if (monster == null) {
+            NavDirections action = SearchFragmentDirections.actionNavigationSearchToNavigationMonster(monster.id.toString());
+            Navigation.findNavController(requireView()).navigate(action);
+        } else {
+            Logger.logError("Can't navigate to MonsterDetail without a monster.");
+        }
+    }
+
+    private static class ViewHolder {
+        final RecyclerView monsterList;
+        final EditText filterQuery;
+
+        public ViewHolder(FragmentSearchBinding binding) {
+            monsterList = binding.monsterList;
+            filterQuery = binding.searchQuery;
+        }
     }
 }

Android/app/src/main/java/com/majinnaibu/monstercards/ui/search/SearchResultsRecyclerViewAdapter.java

@@ -1,88 +1,63 @@
 package com.majinnaibu.monstercards.ui.search;
 
 import android.view.LayoutInflater;
-import android.view.View;
 import android.view.ViewGroup;
 import android.widget.TextView;
 
 import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.DiffUtil;
+import androidx.recyclerview.widget.ListAdapter;
 import androidx.recyclerview.widget.RecyclerView;
 
-import com.majinnaibu.monstercards.R;
+import com.majinnaibu.monstercards.databinding.SimpleListItemBinding;
-import com.majinnaibu.monstercards.data.MonsterRepository;
 import com.majinnaibu.monstercards.models.Monster;
 import com.majinnaibu.monstercards.utils.ItemCallback;
-import com.majinnaibu.monstercards.utils.Logger;
 
-import org.jetbrains.annotations.NotNull;
+public class SearchResultsRecyclerViewAdapter extends ListAdapter<Monster, SearchResultsRecyclerViewAdapter.ViewHolder> {
-
+    private static final DiffUtil.ItemCallback<Monster> DIFF_CALLBACK = new DiffUtil.ItemCallback<Monster>() {
-import java.util.ArrayList;
+        @Override
-import java.util.List;
+        public boolean areItemsTheSame(@NonNull Monster oldItem, @NonNull Monster newItem) {
-
+            return Monster.areItemsTheSame(oldItem, newItem);
-import io.reactivex.rxjava3.core.Flowable;
-import io.reactivex.rxjava3.disposables.Disposable;
-
-public class SearchResultsRecyclerViewAdapter extends RecyclerView.Adapter<SearchResultsRecyclerViewAdapter.ViewHolder> {
-    private final MonsterRepository mRepository;
-    private final ItemCallback<Monster> mOnClickHandler;
-    private String mSearchText;
-    private List<Monster> mValues;
-    private Disposable mSubscriptionHandler;
-    public SearchResultsRecyclerViewAdapter(MonsterRepository repository,
-                                            ItemCallback<Monster> onClick) {
-        mRepository = repository;
-        mSearchText = "";
-        mValues = new ArrayList<>();
-        mOnClickHandler = onClick;
-        mSubscriptionHandler = null;
-
-        doSearch(mSearchText);
-    }
-
-    public void doSearch(String searchText) {
-        if (mSubscriptionHandler != null && !mSubscriptionHandler.isDisposed()) {
-            mSubscriptionHandler.dispose();
         }
-        mSearchText = searchText;
+
-        Flowable<List<Monster>> foundMonsters = mRepository.searchMonsters(mSearchText);
+        @Override
-        mSubscriptionHandler = foundMonsters.subscribe(monsters -> {
+        public boolean areContentsTheSame(@NonNull Monster oldItem, @NonNull Monster newItem) {
-                    mValues = monsters;
+            return Monster.areContentsTheSame(oldItem, newItem);
-                    notifyDataSetChanged();
+        }
-                },
+    };
-                throwable -> Logger.logError("Error performing search", throwable));
+    private final ItemCallback<Monster> mOnClick;
+
+    public SearchResultsRecyclerViewAdapter(ItemCallback<Monster> onClick) {
+        super(DIFF_CALLBACK);
+        mOnClick = onClick;
     }
 
-    @NotNull
+    @NonNull
     @Override
     public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
-        View view = LayoutInflater.from(parent.getContext())
+        SimpleListItemBinding binding = SimpleListItemBinding.inflate(LayoutInflater.from(parent.getContext()), parent, false);
-                .inflate(R.layout.simple_list_item, parent, false);
+        return new ViewHolder(binding);
-        return new ViewHolder(view);
     }
 
     @Override
-    public void onBindViewHolder(final ViewHolder holder, int position) {
+    public void onBindViewHolder(@NonNull final ViewHolder holder, int position) {
-        Monster monster = mValues.get(position);
+        Monster monster = getItem(position);
-        holder.mContentView.setText(monster.name);
+        holder.item = monster;
-        holder.itemView.setTag(monster);
+        holder.contentView.setText(monster.name);
         holder.itemView.setOnClickListener(view -> {
-            if (mOnClickHandler != null) {
+            if (mOnClick != null) {
-                mOnClickHandler.onItem(monster);
+                mOnClick.onItem(holder.item);
             }
         });
     }
 
-    @Override
-    public int getItemCount() {
-        return mValues.size();
-    }
-
     public static class ViewHolder extends RecyclerView.ViewHolder {
-        final TextView mContentView;
+        final TextView contentView;
+        Monster item;
 
-        ViewHolder(View view) {
+        ViewHolder(SimpleListItemBinding binding) {
-            super(view);
+            super(binding.getRoot());
-            mContentView = view.findViewById(R.id.content);
+            contentView = binding.content;
         }
     }
 }

Android/app/src/main/java/com/majinnaibu/monstercards/ui/search/SearchViewModel.java

@@ -1,19 +1,118 @@
 package com.majinnaibu.monstercards.ui.search;
 
+import android.app.Application;
+
+import androidx.lifecycle.AndroidViewModel;
 import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MediatorLiveData;
 import androidx.lifecycle.MutableLiveData;
-import androidx.lifecycle.ViewModel;
 
-public class SearchViewModel extends ViewModel {
+import com.majinnaibu.monstercards.AppDatabase;
+import com.majinnaibu.monstercards.helpers.StringHelper;
+import com.majinnaibu.monstercards.models.Monster;
+import com.majinnaibu.monstercards.utils.Logger;
 
-    private MutableLiveData<String> mSearchQuery;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
 
-    public SearchViewModel() {
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
-        mSearchQuery = new MutableLiveData<>();
+import io.reactivex.rxjava3.schedulers.Schedulers;
-        mSearchQuery.setValue("");
+import io.reactivex.rxjava3.subscribers.DisposableSubscriber;
+
+public class SearchViewModel extends AndroidViewModel {
+    private final MutableLiveData<List<Monster>> mAllMonsters;
+    private final MediatorLiveData<List<Monster>> mFilteredMonsters;
+    private final MutableLiveData<String> mFilterText;
+    private final AppDatabase mDB;
+
+    public SearchViewModel(Application application) {
+        super(application);
+        mDB = AppDatabase.getInstance(application);
+        mAllMonsters = new MutableLiveData<>(new ArrayList<>());
+        mFilterText = new MutableLiveData<>("");
+        mFilteredMonsters = new MediatorLiveData<>();
+        mFilteredMonsters.addSource(
+                mAllMonsters,
+                allMonsters -> mFilteredMonsters.setValue(
+                        filterMonsters(allMonsters, mFilterText.getValue())));
+        mFilteredMonsters.addSource(
+                mFilterText,
+                filterText -> mFilteredMonsters.setValue(
+                        filterMonsters(mAllMonsters.getValue(), filterText)));
+        mDB.monsterDAO()
+                .getAll()
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribeOn(Schedulers.io())
+                .subscribe(new DisposableSubscriber<List<Monster>>() {
+                    @Override
+                    public void onNext(List<Monster> monsters) {
+                        mAllMonsters.setValue(monsters);
+                    }
+
+                    @Override
+                    public void onError(Throwable t) {
+                    }
+
+                    @Override
+                    public void onComplete() {
+                    }
+                });
     }
 
-    public LiveData<String> getSearchQuery() {
+    private boolean monsterMatchesFilter(Monster monster, String filterText) {
-        return mSearchQuery;
+        if (StringHelper.isNullOrEmpty(filterText)) {
+            return true;
+        }
+
+        if (StringHelper.containsCaseInsensitive(monster.name, filterText)) {
+            return true;
+        }
+
+        if (StringHelper.containsCaseInsensitive(monster.size, filterText)) {
+            return true;
+        }
+
+        if (StringHelper.containsCaseInsensitive(monster.type, filterText)) {
+            return true;
+        }
+
+        if (StringHelper.containsCaseInsensitive(monster.subtype, filterText)) {
+            return true;
+        }
+
+        if (StringHelper.containsCaseInsensitive(monster.alignment, filterText)) {
+            return true;
+        }
+
+        return false;
     }
-}
+
+    private List<Monster> filterMonsters(List<Monster> allMonsters, String filterText) {
+        ArrayList<Monster> filteredMonsters = new ArrayList<>();
+        filterText = filterText.toLowerCase(Locale.ROOT);
+        if (allMonsters != null) {
+            for (Monster monster : allMonsters) {
+                // TODO: do the filtering like the iOS app does.
+                Logger.logUnimplementedFeature("do the filtering like the iOS app does");
+                // TODO: consider splitting search text into words and if each word appears in any of these fields return true e.g, "large demon" would match large in size and demon in type.
+                // TODO: add tags and search by tags
+                // TODO: add a display of what fields matched on each item in the results
+                // TODO: make the criteria configurable from this screen
+                // TODO: find a way to add challenge rating as a search criteria
+                if (monsterMatchesFilter(monster, filterText)) {
+                    filteredMonsters.add(monster);
+                }
+            }
+        }
+        return filteredMonsters;
+    }
+
+    public LiveData<List<Monster>> getMatchedMonsters() {
+        return mFilteredMonsters;
+    }
+
+    public void setFilterText(String filterText) {
+        mFilterText.setValue(filterText);
+    }
+}