From cf0df96760583eb3380e9cc7969cbc4dcd8943ab Mon Sep 17 00:00:00 2001 From: Yuri Gorshenin Date: Wed, 12 Oct 2016 19:45:32 +0300 Subject: [PATCH] [search] JNI layer for HotelsFilter. --- .clang-format | 5 + .../jni/com/mapswithme/maps/SearchEngine.cpp | 193 +++++++++++++++++- .../mapswithme/maps/routing/SearchWheel.java | 2 +- .../mapswithme/maps/search/HotelsFilter.java | 90 ++++++++ .../mapswithme/maps/search/SearchEngine.java | 14 +- .../maps/search/SearchFragment.java | 14 +- search/hotels_filter.hpp | 49 +++++ 7 files changed, 355 insertions(+), 12 deletions(-) create mode 100644 android/src/com/mapswithme/maps/search/HotelsFilter.java diff --git a/.clang-format b/.clang-format index cba94dce8d..4ec8deed00 100644 --- a/.clang-format +++ b/.clang-format @@ -22,3 +22,8 @@ NamespaceIndentation: None PointerAlignment: Middle SortIncludes: true Standard: Cpp11 + +--- +Language: Java +BreakBeforeBraces: Allman +ColumnLimit: 100 diff --git a/android/jni/com/mapswithme/maps/SearchEngine.cpp b/android/jni/com/mapswithme/maps/SearchEngine.cpp index 0a4912e815..af6256933a 100644 --- a/android/jni/com/mapswithme/maps/SearchEngine.cpp +++ b/android/jni/com/mapswithme/maps/SearchEngine.cpp @@ -1,10 +1,13 @@ #include "Framework.hpp" #include "search/everywhere_search_params.hpp" +#include "search/hotels_filter.hpp" #include "search/mode.hpp" #include "search/result.hpp" #include "search/viewport_search_params.hpp" +#include "base/logging.hpp" + #include "std/cstdint.hpp" #include "../core/jni_helper.hpp" @@ -16,6 +19,187 @@ using search::Result; namespace { +class HotelsFilterBuilder +{ +public: + using Rule = shared_ptr; + + // *NOTE* keep this in sync with Java counterpart. + enum Type + { + TYPE_AND = 0, + TYPE_OR = 1, + TYPE_OP = 2 + }; + + // *NOTE* keep this in sync with Java counterpart. + enum Field + { + FIELD_RATING = 0, + FIELD_PRICE_RATE = 1 + }; + + // *NOTE* keep this in sync with Java counterpart. + enum Op + { + OP_LT = 0, + OP_LE = 1, + OP_GT = 2, + OP_GE = 3, + OP_EQ = 4 + }; + + void Init(JNIEnv * env) + { + if (m_initialized) + return; + + { + auto const baseClass = env->FindClass("com/mapswithme/maps/search/HotelsFilter"); + m_type = env->GetFieldID(baseClass, "mType", "I"); + } + + { + auto const andClass = env->FindClass("com/mapswithme/maps/search/HotelsFilter$And"); + m_andLhs = env->GetFieldID(andClass, "mLhs", "Lcom/mapswithme/maps/search/HotelsFilter;"); + m_andRhs = env->GetFieldID(andClass, "mRhs", "Lcom/mapswithme/maps/search/HotelsFilter;"); + } + + { + auto const orClass = env->FindClass("com/mapswithme/maps/search/HotelsFilter$Or"); + m_orLhs = env->GetFieldID(orClass, "mLhs", "Lcom/mapswithme/maps/search/HotelsFilter;"); + m_orRhs = env->GetFieldID(orClass, "mRhs", "Lcom/mapswithme/maps/search/HotelsFilter;"); + } + + { + auto const opClass = env->FindClass("com/mapswithme/maps/search/HotelsFilter$Op"); + m_field = env->GetFieldID(opClass, "mField", "I"); + m_op = env->GetFieldID(opClass, "mOp", "I"); + } + + { + auto const ratingFilterClass = + env->FindClass("com/mapswithme/maps/search/HotelsFilter$RatingFilter"); + m_rating = env->GetFieldID(ratingFilterClass, "mValue", "F"); + } + + { + auto const priceRateFilterClass = + env->FindClass("com/mapswithme/maps/search/HotelsFilter$PriceRateFilter"); + m_priceRate = env->GetFieldID(priceRateFilterClass, "mValue", "I"); + } + + m_initialized = true; + } + + Rule Build(JNIEnv * env, jobject filter) + { + if (!m_initialized) + return {}; + + if (!filter) + return {}; + + auto const type = static_cast(env->GetIntField(filter, m_type)); + + switch (type) + { + case TYPE_AND: return BuildAnd(env, filter); + case TYPE_OR: return BuildOr(env, filter); + case TYPE_OP: return BuildOp(env, filter); + } + + LOG(LERROR, ("Unknown type:", type)); + return {}; + } + +private: + Rule BuildAnd(JNIEnv * env, jobject filter) + { + auto const lhs = env->GetObjectField(filter, m_andLhs); + auto const rhs = env->GetObjectField(filter, m_andRhs); + return search::hotels_filter::And(Build(env, lhs), Build(env, rhs)); + } + + Rule BuildOr(JNIEnv * env, jobject filter) + { + auto const lhs = env->GetObjectField(filter, m_orLhs); + auto const rhs = env->GetObjectField(filter, m_orRhs); + return search::hotels_filter::Or(Build(env, lhs), Build(env, rhs)); + } + + Rule BuildOp(JNIEnv * env, jobject filter) + { + auto const field = static_cast(env->GetIntField(filter, m_field)); + auto const op = static_cast(env->GetIntField(filter, m_op)); + + switch (field) + { + case FIELD_RATING: + return BuildRatingOp(env, op, filter); + case FIELD_PRICE_RATE: + return BuildPriceRateOp(env, op, filter); + } + + LOG(LERROR, ("Unknown field:", field)); + return {}; + } + + Rule BuildRatingOp(JNIEnv * env, int op, jobject filter) + { + using namespace search::hotels_filter; + + auto const rating = static_cast(env->GetFloatField(filter, m_rating)); + + switch (op) + { + case OP_LT: return Lt(rating); + case OP_LE: return Le(rating); + case OP_GT: return Gt(rating); + case OP_GE: return Ge(rating); + case OP_EQ: return Eq(rating); + } + + LOG(LERROR, ("Unknown op:", op)); + return {}; + } + + Rule BuildPriceRateOp(JNIEnv * env, int op, jobject filter) + { + using namespace search::hotels_filter; + + auto const priceRate = static_cast(env->GetIntField(filter, m_priceRate)); + + switch (op) + { + case OP_LT: return Lt(priceRate); + case OP_LE: return Le(priceRate); + case OP_GT: return Gt(priceRate); + case OP_GE: return Ge(priceRate); + case OP_EQ: return Eq(priceRate); + } + + LOG(LERROR, ("Unknown op:", op)); + return {}; + } + + jfieldID m_type; + + jfieldID m_andLhs; + jfieldID m_andRhs; + + jfieldID m_orLhs; + jfieldID m_orRhs; + + jfieldID m_field; + jfieldID m_op; + + jfieldID m_rating; + jfieldID m_priceRate; + + bool m_initialized = false; +} g_hotelsFilterBuilder; + // TODO yunitsky // Do not cache search results here, after new search will be implemented. // Currently we cannot serialize FeatureID of search result properly. @@ -180,16 +364,19 @@ extern "C" g_mapResultsMethod = jni::GetMethodID(env, g_javaListener, "onMapSearchResults", "([Lcom/mapswithme/maps/search/NativeMapSearchListener$Result;JZ)V"); g_mapResultClass = jni::GetGlobalClassRef(env, "com/mapswithme/maps/search/NativeMapSearchListener$Result"); g_mapResultCtor = jni::GetConstructorID(env, g_mapResultClass, "(Ljava/lang/String;Ljava/lang/String;)V"); + + g_hotelsFilterBuilder.Init(env); } JNIEXPORT jboolean JNICALL Java_com_mapswithme_maps_search_SearchEngine_nativeRunSearch(JNIEnv * env, jclass clazz, jbyteArray bytes, jstring lang, - jlong timestamp, jboolean hasPosition, jdouble lat, jdouble lon) + jlong timestamp, jboolean hasPosition, jdouble lat, jdouble lon, jobject hotelsFilter) { search::EverywhereSearchParams params; params.m_query = jni::ToNativeString(env, bytes); params.m_inputLocale = ReplaceDeprecatedLanguageCode(jni::ToNativeString(env, lang)); params.m_onResults = bind(&OnResults, _1, timestamp, false, hasPosition, lat, lon); + params.m_hotelsFilter = g_hotelsFilterBuilder.Build(env, hotelsFilter); bool const searchStarted = g_framework->NativeFramework()->SearchEverywhere(params); if (searchStarted) @@ -199,11 +386,12 @@ extern "C" JNIEXPORT void JNICALL Java_com_mapswithme_maps_search_SearchEngine_nativeRunInteractiveSearch(JNIEnv * env, jclass clazz, jbyteArray bytes, - jstring lang, jlong timestamp, jboolean isMapAndTable) + jstring lang, jlong timestamp, jboolean isMapAndTable, jobject hotelsFilter) { search::ViewportSearchParams vparams; vparams.m_query = jni::ToNativeString(env, bytes); vparams.m_inputLocale = ReplaceDeprecatedLanguageCode(jni::ToNativeString(env, lang)); + vparams.m_hotelsFilter = g_hotelsFilterBuilder.Build(env, hotelsFilter); g_framework->NativeFramework()->SearchInViewport(vparams); @@ -214,6 +402,7 @@ extern "C" eparams.m_inputLocale = vparams.m_inputLocale; eparams.m_onResults = bind(&OnResults, _1, timestamp, isMapAndTable, false /* hasPosition */, 0.0 /* lat */, 0.0 /* lon */); + eparams.m_hotelsFilter = vparams.m_hotelsFilter; if (g_framework->NativeFramework()->SearchEverywhere(eparams)) g_queryTimestamp = timestamp; } diff --git a/android/src/com/mapswithme/maps/routing/SearchWheel.java b/android/src/com/mapswithme/maps/routing/SearchWheel.java index 31ff672f2d..457ed8d981 100644 --- a/android/src/com/mapswithme/maps/routing/SearchWheel.java +++ b/android/src/com/mapswithme/maps/routing/SearchWheel.java @@ -233,7 +233,7 @@ class SearchWheel implements View.OnClickListener private void startSearch(SearchOption searchOption) { mCurrentOption = searchOption; - SearchEngine.searchInteractive(searchOption.mSearchQuery, System.nanoTime(), false /* isMapAndTable */); + SearchEngine.searchInteractive(searchOption.mSearchQuery, System.nanoTime(), false /* isMapAndTable */, null /* hotelsFilter */); refreshSearchButtonImage(); toggleSearchLayout(); diff --git a/android/src/com/mapswithme/maps/search/HotelsFilter.java b/android/src/com/mapswithme/maps/search/HotelsFilter.java new file mode 100644 index 0000000000..173ff8abdd --- /dev/null +++ b/android/src/com/mapswithme/maps/search/HotelsFilter.java @@ -0,0 +1,90 @@ +package com.mapswithme.maps.search; + +import android.support.annotation.NonNull; + +public class HotelsFilter +{ + // *NOTE* keep this in sync with JNI counterpart. + public final static int TYPE_AND = 0; + public final static int TYPE_OR = 1; + public final static int TYPE_OP = 2; + + public final int mType; + + protected HotelsFilter(int type) + { + mType = type; + } + + public static class And extends HotelsFilter + { + @NonNull public final HotelsFilter mLhs; + @NonNull public final HotelsFilter mRhs; + + public And(@NonNull HotelsFilter lhs, @NonNull HotelsFilter rhs) + { + super(TYPE_AND); + mLhs = lhs; + mRhs = rhs; + } + } + + public static class Or extends HotelsFilter + { + @NonNull public final HotelsFilter mLhs; + @NonNull public final HotelsFilter mRhs; + + public Or(@NonNull HotelsFilter lhs, @NonNull HotelsFilter rhs) + { + super(TYPE_OR); + mLhs = lhs; + mRhs = rhs; + } + } + + public static class Op extends HotelsFilter + { + // *NOTE* keep this in sync with JNI counterpart. + public final static int FIELD_RATING = 0; + public final static int FIELD_PRICE_RATE = 1; + + // *NOTE* keep this in sync with JNI counterpart. + public final static int OP_LT = 0; + public final static int OP_LE = 1; + public final static int OP_GT = 2; + public final static int OP_GE = 3; + public final static int OP_EQ = 4; + + public final int mField; + public final int mOp; + + protected Op(int field, int op) + { + super(TYPE_OP); + mField = field; + mOp = op; + } + } + + public static class RatingFilter extends Op + { + public final float mValue; + + public RatingFilter(int op, float value) + { + super(FIELD_RATING, op); + mValue = value; + } + } + + public static class PriceRateFilter extends Op + { + public final int mValue; + + public PriceRateFilter(int op, int value) + { + super(FIELD_PRICE_RATE, op); + mValue = value; + } + } +} diff --git a/android/src/com/mapswithme/maps/search/SearchEngine.java b/android/src/com/mapswithme/maps/search/SearchEngine.java index b235e490b8..a6d64b9f2f 100644 --- a/android/src/com/mapswithme/maps/search/SearchEngine.java +++ b/android/src/com/mapswithme/maps/search/SearchEngine.java @@ -8,6 +8,8 @@ import com.mapswithme.util.Language; import com.mapswithme.util.Listeners; import com.mapswithme.util.concurrency.UiThread; +import android.support.annotation.Nullable; + public enum SearchEngine implements NativeSearchListener, NativeMapSearchListener { @@ -95,21 +97,21 @@ public enum SearchEngine implements NativeSearchListener, * @param timestamp Search results are filtered according to it after multiple requests. * @return whether search was actually started. */ - public static boolean search(String query, long timestamp, boolean hasLocation, double lat, double lon) + public static boolean search(String query, long timestamp, boolean hasLocation, double lat, double lon, @Nullable HotelsFilter hotelsFilter) { try { - return nativeRunSearch(query.getBytes("utf-8"), Language.getKeyboardLocale(), timestamp, hasLocation, lat, lon); + return nativeRunSearch(query.getBytes("utf-8"), Language.getKeyboardLocale(), timestamp, hasLocation, lat, lon, hotelsFilter); } catch (UnsupportedEncodingException ignored) { } return false; } - public static void searchInteractive(String query, long timestamp, boolean isMapAndTable) + public static void searchInteractive(String query, long timestamp, boolean isMapAndTable, @Nullable HotelsFilter hotelsFilter) { try { - nativeRunInteractiveSearch(query.getBytes("utf-8"), Language.getKeyboardLocale(), timestamp, isMapAndTable); + nativeRunInteractiveSearch(query.getBytes("utf-8"), Language.getKeyboardLocale(), timestamp, isMapAndTable, hotelsFilter); } catch (UnsupportedEncodingException ignored) { } } @@ -154,12 +156,12 @@ public enum SearchEngine implements NativeSearchListener, /** * @param bytes utf-8 formatted bytes of query. */ - private static native boolean nativeRunSearch(byte[] bytes, String language, long timestamp, boolean hasLocation, double lat, double lon); + private static native boolean nativeRunSearch(byte[] bytes, String language, long timestamp, boolean hasLocation, double lat, double lon, @Nullable HotelsFilter hotelsFilter); /** * @param bytes utf-8 formatted query bytes */ - private static native void nativeRunInteractiveSearch(byte[] bytes, String language, long timestamp, boolean isMapAndTable); + private static native void nativeRunInteractiveSearch(byte[] bytes, String language, long timestamp, boolean isMapAndTable, @Nullable HotelsFilter hotelsFilter); /** * @param bytes utf-8 formatted query bytes diff --git a/android/src/com/mapswithme/maps/search/SearchFragment.java b/android/src/com/mapswithme/maps/search/SearchFragment.java index ed4749b14c..bb8abcd570 100644 --- a/android/src/com/mapswithme/maps/search/SearchFragment.java +++ b/android/src/com/mapswithme/maps/search/SearchFragment.java @@ -380,7 +380,10 @@ public class SearchFragment extends BaseMwmFragment final String query = getQuery(); SearchRecents.add(query); mLastQueryTimestamp = System.nanoTime(); - SearchEngine.searchInteractive(query, mLastQueryTimestamp, false /* isMapAndTable */); + + // TODO (@alexzatsepin): set up hotelsFilter correctly. + SearchEngine.searchInteractive( + query, mLastQueryTimestamp, false /* isMapAndTable */, null /* hotelsFilter */); SearchEngine.showAllResults(query); Utils.navigateToParent(getActivity()); @@ -408,12 +411,17 @@ public class SearchFragment extends BaseMwmFragment // TODO @yunitsky Implement more elegant solution. if (getActivity() instanceof MwmActivity) { - SearchEngine.searchInteractive(getQuery(), mLastQueryTimestamp, true /* isMapAndTable */); + SearchEngine.searchInteractive( + getQuery(), mLastQueryTimestamp, true /* isMapAndTable */, null /* hotelsFilter */); } else { - if (!SearchEngine.search(getQuery(), mLastQueryTimestamp, mLastPosition.valid, mLastPosition.lat, mLastPosition.lon)) + // TODO (@alexzatsepin): set up hotelsFilter correctly. + if (!SearchEngine.search(getQuery(), mLastQueryTimestamp, mLastPosition.valid, + mLastPosition.lat, mLastPosition.lon, null /* hotelsFilter */)) + { return; + } } mSearchRunning = true; diff --git a/search/hotels_filter.hpp b/search/hotels_filter.hpp index 6ea1e9a12a..6c2758a1d1 100644 --- a/search/hotels_filter.hpp +++ b/search/hotels_filter.hpp @@ -8,6 +8,7 @@ #include "std/map.hpp" #include "std/shared_ptr.hpp" +#include "std/string.hpp" #include "std/unique_ptr.hpp" #include "std/utility.hpp" #include "std/vector.hpp" @@ -33,6 +34,8 @@ struct Rating { return d.m_rating; } + + static char const * Name() { return "Rating"; } }; struct PriceRate @@ -50,6 +53,8 @@ struct PriceRate { return d.m_priceRate; } + + static char const * Name() { return "PriceRate"; } }; struct Description @@ -64,6 +69,7 @@ struct Rule { virtual ~Rule() = default; virtual bool Matches(Description const & d) const = 0; + virtual string ToString() const = 0; }; template @@ -79,6 +85,13 @@ struct EqRule : public Rule return Field::Eq(Field::Select(d), m_value); } + string ToString() const override + { + ostringstream os; + os << "[ " << Field::Name() << " == " << m_value << " ]"; + return os.str(); + } + Value const m_value; }; @@ -95,6 +108,13 @@ struct LtRule : public Rule return Field::Lt(Field::Select(d), m_value); } + string ToString() const override + { + ostringstream os; + os << "[ " << Field::Name() << " < " << m_value << " ]"; + return os.str(); + } + Value const m_value; }; @@ -111,6 +131,13 @@ struct GtRule : public Rule return Field::Gt(Field::Select(d), m_value); } + string ToString() const override + { + ostringstream os; + os << "[ " << Field::Name() << " > " << m_value << " ]"; + return os.str(); + } + Value const m_value; }; @@ -129,6 +156,17 @@ struct AndRule : public Rule return matches; } + string ToString() const override + { + ostringstream os; + os << "["; + os << (m_lhs ? m_lhs->ToString() : ""); + os << " && "; + os << (m_rhs ? m_rhs->ToString() : ""); + os << "]"; + return os.str(); + } + shared_ptr m_lhs; shared_ptr m_rhs; }; @@ -148,6 +186,17 @@ struct OrRule : public Rule return matches; } + string ToString() const override + { + ostringstream os; + os << "["; + os << (m_lhs ? m_lhs->ToString() : ""); + os << " || "; + os << (m_rhs ? m_rhs->ToString() : ""); + os << "]"; + return os.str(); + } + shared_ptr m_lhs; shared_ptr m_rhs; };