How and where exactly need to change to accept normal character search from the accented content without changing the UI android

Question

I am using search filtered list. The list contains accented characters.

If I type Cam, it should support and accept Càm but it's not working. I am clueless where exactly I need to give to work in Adapter class.

Here is the code.

public class MainActivity extends AppCompatActivity {

    private HighlightArrayAdapter mHighlightArrayAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Listview sample data
        String products[] = {"Càmdoón", "córean", "Lamià", "dell", "HTC One X", "HTC Wildfire S", "HTC Sense", "HTC Sensàtion XE",
                "iPhone 4S", "Samsóng Galàxy Note 800",
                "Samsung Galàxy S3", "MacBook Air", "Màc Mini", "MàcBook Pro"};

        ListView listView = (ListView) findViewById(R.id.listview);
        EditText editText = (EditText) findViewById(R.id.inputSearch);

        // Adding items to listview
        mHighlightArrayAdapter = new HighlightArrayAdapter(this, R.layout.list_item, R.id.product_name, products);
        listView.setAdapter(mHighlightArrayAdapter);

        // Enabling Search Filter
        editText.addTextChangedListener(new TextWatcher() {

            @Override
            public void onTextChanged(CharSequence cs, int arg1, int arg2, int arg3) {
                mHighlightArrayAdapter.getFilter().filter(cs);
            }

            @Override
            public void beforeTextChanged(CharSequence arg0, int arg1, int arg2,
                                          int arg3) {
            }

            @Override
            public void afterTextChanged(Editable arg0) {
            }
        });
    }
}

//HighlightArrayAdapter.

 public class HighlightArrayAdapter extends ArrayAdapter<String> {
        private final LayoutInflater mInflater;
        private final Context mContext;
        private final int mResource;
        private List<String> mObjects;
        private int mFieldId = 0;
        private ArrayList<String> mOriginalValues;
        private ArrayFilter mFilter;
        private final Object mLock = new Object();
        private String mSearchText; // this var for highlight
        Pattern mPattern;

        public HighlightArrayAdapter(Context context, int resource, int textViewResourceId, String[] objects) {
            super(context, resource, textViewResourceId, objects);
            mContext = context;
            mInflater = LayoutInflater.from(context);
            mResource = resource;
            mObjects = Arrays.asList(objects);
            mFieldId = textViewResourceId;
        }

        @Override
        public Context getContext() {
            return mContext;
        }

        @Override
        public int getCount() {
            return mObjects.size();
        }

        @Override
        public String getItem(int position) {
            return mObjects.get(position);
        }

        @Override
        public int getPosition(String item) {
            return mObjects.indexOf(item);
        }

        @Override
        public Filter getFilter() {
            if (mFilter == null) {
                mFilter = new ArrayFilter();
            }
            return mFilter;
        }

        private class ArrayFilter extends Filter {
            @Override
            protected FilterResults performFiltering(CharSequence prefix) {
                FilterResults results = new FilterResults();

                if (mOriginalValues == null) {
                    synchronized (mLock) {
                        mOriginalValues = new ArrayList<>(mObjects);
                    }
                }

                if (prefix == null || prefix.length() == 0) {
                    mSearchText = "";
                    ArrayList<String> list;
                    synchronized (mLock) {
                        list = new ArrayList<>(mOriginalValues);
                    }
                    results.values = list;
                    results.count = list.size();
                } else {
                    String prefixString = prefix.toString().toLowerCase();
                    mSearchText = prefixString;
                    ArrayList<String> values;
                    synchronized (mLock) {
                        values = new ArrayList<>(mOriginalValues);
                    }

                    final int count = values.size();
                    final ArrayList<String> newValues = new ArrayList<>();

                    for (int i = 0; i < count; i++) {
                        final String value = values.get(i);
                        final String valueText = value.toLowerCase();

                        // First match against the whole, non-splitted value
                        if (valueText.startsWith(prefixString) || valueText.contains(prefixString)) {
                            newValues.add(value);
                        } else {
                            final String[] words = valueText.split(" ");
                            final int wordCount = words.length;

                            // Start at index 0, in case valueText starts with space(s)
                            for (int k = 0; k < wordCount; k++) {
                                if (words[k].startsWith(prefixString) || words[k].contains(prefixString)) {
                                    newValues.add(value);
                                    break;
                                }
                            }
                        }
                    }

                    results.values = newValues;
                    results.count = newValues.size();
                }

                return results;
            }

            @Override
            protected void publishResults(CharSequence constraint, FilterResults results) {
                //noinspection unchecked
                mObjects = (List<String>) results.values;
                if (results.count > 0) {
                    notifyDataSetChanged();
                } else {
                    notifyDataSetInvalidated();
                }
            }
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            View view;
            TextView text;

            if (convertView == null) {
                view = mInflater.inflate(mResource, parent, false);
            } else {
                view = convertView;
            }

            try {
                if (mFieldId == 0) {
                    //  If no custom field is assigned, assume the whole resource is a TextView
                    text = (TextView) view;
                } else {
                    //  Otherwise, find the TextView field within the layout
                    text = (TextView) view.findViewById(mFieldId);
                }
            } catch (ClassCastException e) {
                Log.e("ArrayAdapter", "You must supply a resource ID for a TextView");
                throw new IllegalStateException(
                        "ArrayAdapter requires the resource ID to be a TextView", e);
            }

            // HIGHLIGHT...

            String fullText = getItem(position);
            if (mSearchText != null && !mSearchText.isEmpty()) {
                int startPos = fullText.toLowerCase(Locale.US).indexOf(mSearchText.toLowerCase(Locale.US));
                int endPos = startPos + mSearchText.length();

                if (startPos != -1) {
                    //Spannable spannable = new SpannableString(removeAccents(fullText)); // i used removeAccents but not worked.
                    Spannable spannable = new SpannableString(fullText);
                    ColorStateList blueColor = new ColorStateList(new int[][]{new int[]{}}, new int[]{Color.BLUE});
                    TextAppearanceSpan highlightSpan = new TextAppearanceSpan(null, Typeface.BOLD, -1, blueColor, null);
                    spannable.setSpan(highlightSpan, startPos, endPos, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                    text.setText(spannable);
                } else {
                    text.setText(fullText);
                }
            } else {
                text.setText(fullText);
            }

            return view;
        }

       /* public static String removeAccents(String text) {
            return text == null ? null : Normalizer.normalize(text, Normalizer.Form.NFD)
                    .replaceAll("\\p{InCombiningDiacriticalMarks}+", "");
        }*/

        /*private SpannableStringBuilder createHighlightedString(String nodeText, int highlightColor) {
            SpannableStringBuilder returnValue = new SpannableStringBuilder(nodeText);

            String lowercaseNodeText = nodeText.toLowerCase();
            Matcher matcher = mSearchText.matcher(lowercaseNodeText);
            while (matcher.find()) {
                returnValue.setSpan(new ForegroundColorSpan(highlightColor), matcher.start(0),
                        matcher.end(0), Spannable.SPAN_EXCLUSIVE_INCLUSIVE);
            }

            return returnValue;
        }*/
    }

Here is the screenshot.

Scenario 1: (This is working)

Scenario 2: ( This is not working when I type normal character of a):

Scenario 3: (This is working when I type accented character):

So how to make Scenario 2 to work when I give normal character search in word to support the accented character list to accept.

I used InCombiningDiacriticalMarks but it's not working i am clueless where exactly need to give.

Kindly help me please in adapter class.

Answer 1

You should match your filtered list to a diactritics-less String.

public static String removeDiacritics(String input) {
    String out = "" + input;
    out = out.replaceAll(" ", "");
    out = out.replaceAll("[èéêë]", "e");
    out = out.replaceAll("[ûù]", "u");
    out = out.replaceAll("[ïî]", "i");
    out = out.replaceAll("[àâ]", "a");
    out = out.replaceAll("Ô", "o");

    out = out.replaceAll("[ÈÉÊË]", "E");
    out = out.replaceAll("[ÛÙ]", "U");
    out = out.replaceAll("[ÏÎ]", "I");
    out = out.replaceAll("[ÀÂ]", "A");
    out = out.replaceAll("Ô", "O");

    out = out.replaceAll("-", "");

    return out;
}

This way you will not be matching "Cam" with "Càm" anymore, but "Cam" with "Cam". You should also transform your strings to lower (or upper) case to be Upper-case permissive.

hope it helps!