Add filter name edition

app/src/main/AndroidManifest.xml

@@ -109,6 +109,11 @@
 			android:launchMode="singleTop"
 			android:screenOrientation="portrait" />
 
+		<activity
+			android:name="net.pokeranalytics.android.ui.activity.FiltersListActivity"
+			android:launchMode="singleTop"
+			android:screenOrientation="portrait" />
+
 		<activity
 			android:name="net.pokeranalytics.android.ui.activity.EditableDataActivity"
 			android:launchMode="singleTop"

app/src/main/java/net/pokeranalytics/android/model/realm/Filter.kt

@@ -1,7 +1,10 @@
 package net.pokeranalytics.android.model.realm
 
 import android.content.Context
-import io.realm.*
+import io.realm.Realm
+import io.realm.RealmList
+import io.realm.RealmObject
+import io.realm.RealmResults
 import io.realm.annotations.PrimaryKey
 import io.realm.kotlin.where
 import net.pokeranalytics.android.R
@@ -11,11 +14,15 @@ import net.pokeranalytics.android.model.filter.QueryCondition
 import net.pokeranalytics.android.model.interfaces.CountableUsage
 import net.pokeranalytics.android.model.interfaces.Deletable
 import net.pokeranalytics.android.model.interfaces.DeleteValidityStatus
-import net.pokeranalytics.android.model.interfaces.Identifiable
+import net.pokeranalytics.android.model.interfaces.Editable
+import net.pokeranalytics.android.ui.fragment.components.bottomsheet.BottomSheetType
 import net.pokeranalytics.android.ui.interfaces.FilterableType
 import net.pokeranalytics.android.ui.view.ImageDecorator
 import net.pokeranalytics.android.ui.view.RowRepresentable
+import net.pokeranalytics.android.ui.view.RowRepresentableEditDescriptor
+import net.pokeranalytics.android.ui.view.RowViewType
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow
+import timber.log.Timber
 import java.util.*
 
 /**
@@ -23,14 +30,14 @@ import java.util.*
  * It contains a list of [FilterCondition] describing the complete query to launch
  * The [Filter] is working closely with a [Filterable] interface providing the entity we want the query being launched on
  */
-open class Filter : RealmObject(), RowRepresentable, Identifiable, Deletable, CountableUsage, ImageDecorator {
+open class Filter : RealmObject(), RowRepresentable, Editable, Deletable, CountableUsage, ImageDecorator {
 
 	companion object {
 
 		// Create a new instance
-		fun newInstance(filterableTypeUniqueIdentifier:Int): Filter {
+		fun newInstance(filterableTypeUniqueIdentifier: Int): Filter {
 			val filter = Filter()
-            filter.filterableTypeUniqueIdentifier = filterableTypeUniqueIdentifier
+			filter.filterableTypeUniqueIdentifier = filterableTypeUniqueIdentifier
 			return filter
 			//return realm.copyToRealm(filter)
 		}
@@ -40,139 +47,172 @@ open class Filter : RealmObject(), RowRepresentable, Identifiable, Deletable, Co
 			return realm.where<Filter>().equalTo("id", filterId).findFirst()
 		}
 
-	    inline fun <reified T : Filterable> queryOn(realm: Realm, query: Query, sortField: String? = null): RealmResults<T> {
+		inline fun <reified T : Filterable> queryOn(realm: Realm, query: Query, sortField: String? = null): RealmResults<T> {
-            val realmQuery = realm.where<T>()
+			val realmQuery = realm.where<T>()
-            sortField?.let {
+			sortField?.let {
-                return query.queryWith(realmQuery).sort(it).findAll()
+				return query.queryWith(realmQuery).sort(it).findAll()
-            } ?: run {
+			} ?: run {
-                return query.queryWith(realmQuery).findAll()
+				return query.queryWith(realmQuery).findAll()
-            }
+			}
-        }
+		}
-    }
+	}
+
+	override val viewType: Int
+		get() = RowViewType.TITLE_VALUE_ACTION.ordinal
+	override val imageRes: Int?
+		get() = R.drawable.ic_outline_settings
+	override val imageTint: Int?
+		get() = R.color.green
+	override val imageClickable: Boolean?
+		get() = true
+
 
 	@PrimaryKey
-    override var id = UUID.randomUUID().toString()
+	override var id = UUID.randomUUID().toString()
 
 	// the queryWith name
 	var name: String = ""
-        get() {
+		get() {
-            if (field.isEmpty()) {
+			if (field.isEmpty()) {
-                return this.query.defaultName
+				return this.query.defaultName
-            }
+			}
-            return field
+			return field
-        }
+		}
 
-    override var useCount: Int = 0
+	override var useCount: Int = 0
 
 	var filterConditions: RealmList<FilterCondition> = RealmList()
 		private set
 
-    private var filterableTypeUniqueIdentifier: Int? = null
+	private var filterableTypeUniqueIdentifier: Int? = null
 
-    val filterableType: FilterableType
+	val filterableType: FilterableType
-        get() {
+		get() {
-            this.filterableTypeUniqueIdentifier?.let {
+			this.filterableTypeUniqueIdentifier?.let {
-                return FilterableType.valueByIdentifier(it)
+				return FilterableType.valueByIdentifier(it)
-            }
+			}
-            return FilterableType.ALL
+			return FilterableType.ALL
-        }
+		}
 
 	fun createOrUpdateFilterConditions(filterConditionRows: ArrayList<QueryCondition>) {
-        println("list of querys saving: ${filterConditionRows.map { it.id }}")
+		Timber.d("list of querys saving: ${filterConditionRows.map { it.id }}")
-        println("list of querys previous: ${this.filterConditions.map { it.queryCondition.id }}")
+		Timber.d("list of querys previous: ${this.filterConditions.map { it.queryCondition.id }}")
-        filterConditionRows
+		filterConditionRows
 			.map {
 				it.groupId
 			}
 			.distinct()
-			.forEach { groupId->
+			.forEach { groupId ->
 				filterConditionRows
 					.filter {
 						it.groupId == groupId
 					}
 					.apply {
 
-                        println("list of querys: ${this.map { it.id }}")
+						Timber.d("list of querys: ${this.map { it.id }}")
-                        val casted = arrayListOf<QueryCondition>()
+						val casted = arrayListOf<QueryCondition>()
-                        casted.addAll(this)
+						casted.addAll(this)
-                        val newFilterCondition = FilterCondition(casted)
+						val newFilterCondition = FilterCondition(casted)
-                        val previousCondition = filterConditions.filter {
+						val previousCondition = filterConditions.filter {
-                            it.filterName == newFilterCondition.filterName && it.operator == newFilterCondition.operator
+							it.filterName == newFilterCondition.filterName && it.operator == newFilterCondition.operator
-                        }
+						}
-                        filterConditions.removeAll(previousCondition)
+						filterConditions.removeAll(previousCondition)
-                        filterConditions.add(newFilterCondition)
+						filterConditions.add(newFilterCondition)
-                    }
+					}
 			}
 	}
 
-    fun remove(filterCategoryRow: FilterCategoryRow) {
+	fun remove(filterCategoryRow: FilterCategoryRow) {
-        val sections = filterCategoryRow.filterSectionRows.map { it.name }
+		val sections = filterCategoryRow.filterSectionRows.map { it.name }
-        val savedSections = filterConditions.filter { sections.contains(it.sectionName) }
+		val savedSections = filterConditions.filter { sections.contains(it.sectionName) }
-        this.filterConditions.removeAll(savedSections)
+		this.filterConditions.removeAll(savedSections)
-    }
+	}
 
 	fun countBy(filterCategoryRow: FilterCategoryRow): Int {
 		val sections = filterCategoryRow.filterSectionRows.map { it.name }
-        println("list of sections $sections")
+		Timber.d("list of sections $sections")
-        val savedSections = filterConditions.filter { sections.contains(it.sectionName) }.flatMap { it.queryCondition.id }
+		val savedSections = filterConditions.filter { sections.contains(it.sectionName) }.flatMap { it.queryCondition.id }
-        println("list of savedSections $savedSections")
+		Timber.d("list of savedSections $savedSections")
-        return savedSections.size
+		return savedSections.size
 	}
 
 	fun contains(filterElementRow: QueryCondition): Boolean {
-        println("list of saved queries ${filterConditions.map { it.queryCondition.id }}")
+		Timber.d("list of saved queries ${filterConditions.map { it.queryCondition.id }}")
-        println("list of contains ${filterElementRow.id}")
+		Timber.d("list of contains ${filterElementRow.id}")
-		val contained = filterConditions.flatMap{ it.queryCondition.id }.contains(filterElementRow.id.first())
+		val contained = filterConditions.flatMap { it.queryCondition.id }.contains(filterElementRow.id.first())
-        println("list of : $contained")
+		Timber.d("list of : $contained")
-        return contained
+		return contained
 	}
 
 	/**
 	 * Get the saved value for the given [filterElementRow]
 	 */
-    fun loadValueForElement(filterElementRow: QueryCondition) {
+	fun loadValueForElement(filterElementRow: QueryCondition) {
 		val filtered = filterConditions.filter {
 			it.queryCondition.id == filterElementRow.id
 		}
 		if (filtered.isNotEmpty()) {
-            return filterElementRow.updateValueBy(filtered.first())
+			return filterElementRow.updateValueBy(filtered.first())
 		}
 	}
 
 	inline fun <reified T : Filterable> results(firstField: String? = null, secondField: String? = null): RealmResults<T> {
 
-        val realmQuery = realm.where<T>()
+		val realmQuery = realm.where<T>()
 
-        if (firstField != null && secondField != null) {
+		if (firstField != null && secondField != null) {
-            return this.query.queryWith(realmQuery).distinct(firstField, secondField).findAll()
+			return this.query.queryWith(realmQuery).distinct(firstField, secondField).findAll()
-        }
+		}
 
-        if (firstField != null) {
+		if (firstField != null) {
-            return this.query.queryWith(realmQuery).distinct(firstField).findAll()
+			return this.query.queryWith(realmQuery).distinct(firstField).findAll()
-        }
+		}
 
-        return this.query.queryWith(realmQuery).findAll()
+		return this.query.queryWith(realmQuery).findAll()
-    }
+	}
 
-    val query: Query
+	val query: Query
-        get() {
+		get() {
-            val query = Query()
+			val query = Query()
-            this.filterConditions.forEach {
+			this.filterConditions.forEach {
-                query.add(it.queryCondition)
+				query.add(it.queryCondition)
-            }
+			}
-            return query
+			return query
-        }
+		}
 
-    override fun getDisplayName(context: Context): String {
+	override fun getDisplayName(context: Context): String {
-        if (name.isNotEmpty()) return name
+		if (name.isNotEmpty()) return name
-        return this.query.getName(context)
+		return this.query.getName(context)
-    }
+	}
 
-    override fun isValidForDelete(realm: Realm): Boolean {
+	override fun isValidForDelete(realm: Realm): Boolean {
 		return true
 	}
 
 	override fun getFailedDeleteMessage(status: DeleteValidityStatus): Int {
 		return R.string.relationship_error
 	}
+
+	override val bottomSheetType: BottomSheetType
+		get() {
+			return BottomSheetType.EDIT_TEXT
+		}
+
+	override fun localizedTitle(context: Context): String {
+		return context.getString(R.string.name)
+	}
+
+	override fun editingDescriptors(map: Map<String, Any?>): ArrayList<RowRepresentableEditDescriptor>? {
+		val defaultValue: String? by map
+		return arrayListOf(RowRepresentableEditDescriptor(defaultValue, R.string.name))
+	}
+
+	override fun updateValue(value: Any?, row: RowRepresentable) {
+		realm.executeTransaction {
+			val newName = value as String? ?: ""
+			if (newName.isNotEmpty()) {
+				name = newName
+			}
+		}
+	}
 }

app/src/main/java/net/pokeranalytics/android/ui/activity/FiltersListActivity.kt

@@ -0,0 +1,58 @@
+package net.pokeranalytics.android.ui.activity
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import androidx.fragment.app.Fragment
+import kotlinx.android.synthetic.main.activity_filters_list.*
+import net.pokeranalytics.android.R
+import net.pokeranalytics.android.ui.activity.components.PokerAnalyticsActivity
+import net.pokeranalytics.android.ui.fragment.FiltersListFragment
+import net.pokeranalytics.android.ui.interfaces.FilterActivityRequestCode
+
+class FiltersListActivity : PokerAnalyticsActivity() {
+
+	enum class IntentKey(val keyName: String) {
+		DATA_TYPE("DATA_TYPE"),
+		LIVE_DATA_TYPE("LIVE_DATA_TYPE"),
+		ITEM_DELETED("ITEM_DELETED"),
+		SHOW_ADD_BUTTON("SHOW_ADD_BUTTON"),
+	}
+
+	companion object {
+		fun newInstance(context: Context, dataType: Int) {
+			context.startActivity(getIntent(context, dataType))
+		}
+
+		fun newSelectInstance(fragment: Fragment, dataType: Int, showAddButton: Boolean = true) {
+			val context = fragment.requireContext()
+			fragment.startActivityForResult(getIntent(context, dataType, showAddButton), FilterActivityRequestCode.SELECT_FILTER.ordinal)
+		}
+
+		private fun getIntent(context: Context, dataType: Int, showAddButton: Boolean = true): Intent {
+			val intent = Intent(context, FiltersListActivity::class.java)
+			intent.putExtra(IntentKey.DATA_TYPE.keyName, dataType)
+			intent.putExtra(IntentKey.SHOW_ADD_BUTTON.keyName, showAddButton)
+			return intent
+		}
+	}
+
+	override fun onCreate(savedInstanceState: Bundle?) {
+		super.onCreate(savedInstanceState)
+		setContentView(R.layout.activity_filters_list)
+
+		initUI()
+	}
+
+	/**
+	 * Init UI
+	 */
+	private fun initUI() {
+		val dataType = intent.getIntExtra(IntentKey.DATA_TYPE.keyName, 0)
+		val showAddButton = intent.getBooleanExtra(IntentKey.SHOW_ADD_BUTTON.keyName, true)
+		val fragment = filtersListFragment as FiltersListFragment
+		fragment.setData(dataType)
+		fragment.updateUI(showAddButton)
+	}
+
+}

app/src/main/java/net/pokeranalytics/android/ui/fragment/DataListFragment.kt

@@ -11,7 +11,6 @@ import androidx.recyclerview.widget.ItemTouchHelper
 import androidx.recyclerview.widget.LinearLayoutManager
 import io.realm.Realm
 import io.realm.RealmResults
-import io.realm.kotlin.isValid
 import kotlinx.android.synthetic.main.fragment_data_list.*
 import net.pokeranalytics.android.R
 import net.pokeranalytics.android.model.LiveData
@@ -25,7 +24,6 @@ import net.pokeranalytics.android.ui.adapter.RowRepresentableAdapter
 import net.pokeranalytics.android.ui.adapter.RowRepresentableDelegate
 import net.pokeranalytics.android.ui.fragment.components.DeletableItemFragment
 import net.pokeranalytics.android.ui.helpers.SwipeToDeleteCallback
-import net.pokeranalytics.android.ui.interfaces.FilterableType
 import net.pokeranalytics.android.ui.view.RowRepresentable
 import net.pokeranalytics.android.ui.view.RowViewType
 import net.pokeranalytics.android.util.extensions.sorted
@@ -45,7 +43,7 @@ open class DataListFragment : DeletableItemFragment(), LiveRowRepresentableDataS
 	/**
 	 * Set fragment data
 	 */
-	fun setData(dataType: Int) {
+	open fun setData(dataType: Int) {
 
 		this.dataType = LiveData.values()[dataType]
 		this.identifiableClass = this.dataType.relatedEntity

app/src/main/java/net/pokeranalytics/android/ui/fragment/FiltersFragment.kt

@@ -14,9 +14,9 @@ import kotlinx.android.synthetic.main.fragment_filters.view.toolbar
 import net.pokeranalytics.android.R
 import net.pokeranalytics.android.model.LiveData
 import net.pokeranalytics.android.model.realm.Filter
-import net.pokeranalytics.android.ui.activity.DataListActivity
 import net.pokeranalytics.android.ui.activity.FilterDetailsActivity
 import net.pokeranalytics.android.ui.activity.FiltersActivity
+import net.pokeranalytics.android.ui.activity.FiltersListActivity
 import net.pokeranalytics.android.ui.adapter.RowRepresentableAdapter
 import net.pokeranalytics.android.ui.adapter.RowRepresentableDelegate
 import net.pokeranalytics.android.ui.adapter.StaticRowRepresentableDataSource
@@ -159,7 +159,7 @@ open class FiltersFragment : RealmFragment(), StaticRowRepresentableDataSource,
 
 		moreFilters.setOnClickListener {
             LiveData.FILTER.subType = filterableType.uniqueIdentifier
-			DataListActivity.newSelectInstance(this, LiveData.FILTER.ordinal, false)
+			FiltersListActivity.newSelectInstance(this, LiveData.FILTER.ordinal, false)
 		}
 
 		mostUsedFiltersLayout.isVisible = showMostUsedFiltersLayout

app/src/main/java/net/pokeranalytics/android/ui/fragment/FiltersListFragment.kt

@@ -0,0 +1,122 @@
+package net.pokeranalytics.android.ui.fragment
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import io.realm.RealmResults
+import net.pokeranalytics.android.model.LiveData
+import net.pokeranalytics.android.model.interfaces.Deletable
+import net.pokeranalytics.android.model.interfaces.Identifiable
+import net.pokeranalytics.android.model.realm.Filter
+import net.pokeranalytics.android.ui.activity.EditableDataActivity
+import net.pokeranalytics.android.ui.activity.FiltersActivity
+import net.pokeranalytics.android.ui.fragment.components.bottomsheet.BottomSheetFragment
+import net.pokeranalytics.android.ui.interfaces.FilterHandler.Companion.INTENT_FILTER_UPDATE_FILTER_UI
+import net.pokeranalytics.android.ui.view.RowRepresentable
+import net.pokeranalytics.android.ui.view.RowRepresentableEditDescriptor
+import net.pokeranalytics.android.ui.view.RowViewType
+import net.pokeranalytics.android.util.Preferences
+import timber.log.Timber
+
+
+open class FiltersListFragment : DataListFragment() {
+
+	private var identifiableClass: Class<out Deletable> = Filter::class.java
+	private var dataType: LiveData = LiveData.FILTER
+	private lateinit var items: RealmResults<Filter>
+
+	/**
+	 * Set fragment data
+	 */
+	override fun setData(dataType: Int) {
+		super.setData(dataType)
+
+		this.dataType = LiveData.FILTER
+		this.identifiableClass = Filter::class.java
+		setToolbarTitle(this.dataType.pluralLocalizedTitle(requireContext()))
+		this.items = this.retrieveItems(getRealm()) as RealmResults<Filter>
+	}
+
+	override fun rowRepresentableForPosition(position: Int): RowRepresentable? {
+		Timber.d("rowRepresentableForPosition: ${this.items[position] as RowRepresentable}")
+		return this.items[position] as RowRepresentable
+	}
+
+	override fun numberOfRows(): Int {
+		return this.items.size
+	}
+
+	override fun adapterRows(): List<RowRepresentable>? {
+		return items
+	}
+
+	override fun viewTypeForPosition(position: Int): Int {
+		val viewType = (this.items[position] as RowRepresentable).viewType
+		return if (viewType != -1) viewType else RowViewType.DATA.ordinal
+	}
+
+	override fun editDescriptors(row: RowRepresentable): ArrayList<RowRepresentableEditDescriptor>? {
+		return when (row) {
+			is Filter -> row.editingDescriptors(mapOf("defaultValue" to row.name))
+			else -> super.editDescriptors(row)
+		}
+	}
+
+	override fun onRowValueChanged(value: Any?, row: RowRepresentable) {
+		when (row) {
+			is Filter -> {
+				row.updateValue(value, row)
+				dataListAdapter.refreshRow(row)
+				updateFilterUIIfNecessary(requireContext(), row.id)
+			}
+			else -> super.onRowValueChanged(value, row)
+		}
+	}
+
+	override fun onRowDeleted(row: RowRepresentable) {
+		when (row) {
+			is Filter -> {
+				val filterId = row.id
+				deleteItem(dataListAdapter, items, filterId)
+				if (filterId == Preferences.getActiveFilterId(requireContext())) {
+					Preferences.setActiveFilterId("", requireContext())
+					updateFilterUIIfNecessary(requireContext(), "")
+				}
+			}
+			else -> super.onRowDeleted(row)
+		}
+	}
+
+	override fun onRowSelected(position: Int, row: RowRepresentable, fromAction: Boolean) {
+		when (row) {
+			is Filter -> {
+				if (fromAction) {
+					val data = row.editingDescriptors(mapOf("defaultValue" to row.name))
+					BottomSheetFragment.create(fragmentManager, row, this, data, false, isDeletable = true, valueHasPlaceholder = false)
+				} else {
+					val intent = Intent()
+					intent.putExtra(FiltersActivity.IntentKey.FILTER_ID.keyName, row.id)
+					activity?.setResult(Activity.RESULT_OK, intent)
+					activity?.finish()
+				}
+			}
+			else -> {
+				val identifier = (row as Identifiable).id
+				EditableDataActivity.newInstanceForResult(this, this.dataType, identifier, REQUEST_CODE_DETAILS)
+			}
+		}
+	}
+
+	/**
+	 * Update filter UI
+	 */
+	fun updateFilterUIIfNecessary(context: Context, filterId: String) {
+		if (filterId == Preferences.getActiveFilterId(context)) {
+			// Send broadcast
+			val intent = Intent()
+			intent.action = INTENT_FILTER_UPDATE_FILTER_UI
+			context.sendBroadcast(intent)
+		}
+	}
+
+}

app/src/main/java/net/pokeranalytics/android/ui/fragment/components/bottomsheet/BottomSheetDoubleEditTextFragment.kt

@@ -42,7 +42,6 @@ class BottomSheetDoubleEditTextFragment : BottomSheetFragment() {
 	 * Init data
 	 */
 	private fun initData() {
-		valueHasPlaceholder = true
 		isEditingBlinds = row == SessionRow.BLINDS
 	}
 

app/src/main/java/net/pokeranalytics/android/ui/fragment/components/bottomsheet/BottomSheetEditTextFragment.kt

@@ -43,7 +43,6 @@ class BottomSheetEditTextFragment : BottomSheetFragment() {
 	 * Init data
 	 */
 	private fun initData() {
-		valueHasPlaceholder = true
 	}
 
 	/**

app/src/main/java/net/pokeranalytics/android/ui/fragment/components/bottomsheet/BottomSheetFragment.kt

@@ -48,7 +48,7 @@ open class BottomSheetFragment : BottomSheetDialogFragment() {
 			isClearable: Boolean? = true,
 			currentCurrency: Currency? = null,
 			isDeletable: Boolean? = false,
-			valueHasPlaceholder: Boolean? = false
+			valueHasPlaceholder: Boolean? = null
 		): BottomSheetFragment {
 			val bottomSheetFragment = row.bottomSheetType.newInstance()
 			bottomSheetFragment.show(fragmentManager, "bottomSheet")

app/src/main/java/net/pokeranalytics/android/ui/fragment/components/bottomsheet/BottomSheetNumericTextFragment.kt

@@ -36,7 +36,6 @@ class BottomSheetNumericTextFragment : BottomSheetFragment() {
 	 * Init data
 	 */
 	private fun initData() {
-		valueHasPlaceholder = true
 	}
 
 	/**

app/src/main/java/net/pokeranalytics/android/ui/interfaces/FilterHandler.kt

@@ -12,69 +12,69 @@ import net.pokeranalytics.android.util.enumerations.IntIdentifiable
 import net.pokeranalytics.android.util.enumerations.IntSearchable
 
 enum class FilterActivityRequestCode {
-    SELECT_FILTER,
+	SELECT_FILTER,
-    CREATE_FILTER,
+	CREATE_FILTER,
-    ;
+	;
 }
 
-enum class FilterableType(override var uniqueIdentifier: Int): IntIdentifiable {
+enum class FilterableType(override var uniqueIdentifier: Int) : IntIdentifiable {
-    ALL(0),
+	ALL(0),
-    SESSION(1),
+	SESSION(1),
-    TRANSACTION(2),
+	TRANSACTION(2),
-    BANKROLL(3),
+	BANKROLL(3),
-    HAND_HISTORY(4),
+	HAND_HISTORY(4),
-    ;
+	;
 
-    companion object : IntSearchable<FilterableType> {
+	companion object : IntSearchable<FilterableType> {
 
-        override fun valuesInternal(): Array<FilterableType> {
+		override fun valuesInternal(): Array<FilterableType> {
-            return values()
+			return values()
-        }
+		}
-    }
+	}
 
 }
 
 interface FilterHandler {
-    companion object {
+	companion object {
-        const val INTENT_FILTER_UPDATE_FILTER_UI = "net.pokeranalytics.android.UPDATE_FILTER_UI"
+		const val INTENT_FILTER_UPDATE_FILTER_UI = "net.pokeranalytics.android.UPDATE_FILTER_UI"
-    }
+	}
-
+
-    fun applyFilter()
+	fun applyFilter()
-    fun removeFilter()
+	fun removeFilter()
-
+
-    fun saveFilter(context: Context, filterId:String) {
+	fun saveFilter(context: Context, filterId: String) {
-        Preferences.setActiveFilterId(filterId, context)
+		Preferences.setActiveFilterId(filterId, context)
-
+
-
+
-        val realm = Realm.getDefaultInstance()
+		val realm = Realm.getDefaultInstance()
-        realm.beginTransaction()
+		realm.beginTransaction()
-        currentFilter(context, realm)?.let {
+		currentFilter(context, realm)?.let {
-            it.useCount++
+			it.useCount++
-        }
+		}
-        realm.commitTransaction()
+		realm.commitTransaction()
-        realm.close()
+		realm.close()
-
+
-        // Send broadcast
+		// Send broadcast
-        val intent = Intent()
+		val intent = Intent()
-        intent.action = INTENT_FILTER_UPDATE_FILTER_UI
+		intent.action = INTENT_FILTER_UPDATE_FILTER_UI
-        context.sendBroadcast(intent)
+		context.sendBroadcast(intent)
-    }
+	}
-
+
-    fun currentFilter(context: Context, realm: Realm): Filter? {
+	fun currentFilter(context: Context, realm: Realm): Filter? {
-        return Preferences.getActiveFilterId(context)?.let {
+		return Preferences.getActiveFilterId(context)?.let {
-            realm.where<Filter>().equalTo("id", it).findFirst()
+			realm.where<Filter>().equalTo("id", it).findFirst()
-        } ?: run {
+		} ?: run {
-            null
+			null
-        }
+		}
-    }
+	}
-
+
-    var currentFilterable: FilterableType
+	var currentFilterable: FilterableType
-
+
-
+
-    /**
+	/**
-     * Manage filters
+	 * Manage filters
-     */
+	 */
-    fun manageFilters(fragment: Fragment) {
+	fun manageFilters(fragment: Fragment) {
-        FiltersActivity.newInstanceForResult(fragment = fragment, currentFilterable = currentFilterable)
+		FiltersActivity.newInstanceForResult(fragment = fragment, currentFilterable = currentFilterable)
-    }
+	}
 }

app/src/main/res/layout/activity_filters_list.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+	xmlns:tools="http://schemas.android.com/tools"
+	android:layout_width="match_parent"
+	android:layout_height="match_parent"
+	android:orientation="vertical">
+
+	<fragment
+		android:id="@+id/filtersListFragment"
+		android:name="net.pokeranalytics.android.ui.fragment.FiltersListFragment"
+		android:layout_width="match_parent"
+		android:layout_height="match_parent"
+		tools:layout="@layout/fragment_data_list" />
+
+</LinearLayout>