ArrayAdapter Filteration fonctionne uniquement pour la première fois. Échec à l'entrée suivante

Question

J'ai appliqué un filtre sur la liste personnalisée de ArrayAdapter d'objets. J'ai appliqué la filtration et cela ne fonctionne que pour la première fois. Quand j'ai essayé d'enlever le texte filtré et d'entrer un autre, il ne me donne pas les données mises à jour dans ListView. Voici mon code pour elle,

classe Adaptateur

public class ServiceListAdapter extends ArrayAdapter<ServiceItem> implements Filterable { 

private Context mContext; 
private List<ServiceItem> serviceItemList; 
private List<ServiceItem> nameList; 
private LayoutInflater inflater; 
private int layoutId; 
private ServiceFilter filter; 


public ServiceListAdapter(Context context, int resource, List<ServiceItem> serviceItemList) { 
    super(context, resource, serviceItemList); 

    this.mContext = context; 
    this.serviceItemList = serviceItemList; 
    this.layoutId = resource; 
    this.inflater = (LayoutInflater) getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE); 
} 

@Override 
public View getView(int position, View convertView, ViewGroup parent) { 

    View v = convertView; 
    ServiceHolder sHolder = null; 

    if (v == null) { 

     v = inflater.inflate(layoutId, null); 

     sHolder = new ServiceHolder(); 
     sHolder.serviceName = (TextView) v.findViewById(R.id.serviceName); 
     sHolder.serviceDetail = (TextView) v.findViewById(R.id.serviceDetail); 
     sHolder.serviceImg = (ImageView) v.findViewById(R.id.serviceImg); 
     sHolder.btnGo = (Button) v.findViewById(R.id.btnGo); 

     v.setTag(sHolder); 
    } else { 

     sHolder = (ServiceHolder) convertView.getTag(); 
    } 

    ServiceItem serviceItem = getItem(position); 
    sHolder.serviceName.setText(serviceItem.getServiceName()); 
    sHolder.serviceDetail.setText(serviceItem.getServiceDetail()); 
    sHolder.serviceImg.setImageResource(serviceItem.getServiceImg()); 

    sHolder.btnGo.setOnClickListener(new View.OnClickListener() { 
     @Override 
     public void onClick(View v) { 


     } 
    }); 


    return v; 
} 

static class ServiceHolder { 

    TextView serviceName; 
    TextView serviceDetail; 
    ImageView serviceImg; 
    Button btnGo; 

} 

@Override 
public ServiceItem getItem(int position) { 
    return serviceItemList.get(position); 
} 

@Override 
public Filter getFilter() { 

    if (filter == null) { 
     filter = new ServiceFilter(); 
    } 
    return filter; 

} 

private class ServiceFilter extends Filter { 


    private static final String TAG = "Filter"; 

    @Override 
    protected FilterResults performFiltering(CharSequence constraint) { 


     FilterResults filterResults = new FilterResults(); 


     Log.d(TAG, "Length: " + constraint.toString().length()); 

     if (constraint != "" && constraint.toString().length() > 0) { 

      ArrayList<ServiceItem> filterItems = new ArrayList<>(); 
      ArrayList<ServiceItem> sItems = new ArrayList<>(); 

      synchronized (this) 
      { 
       sItems.addAll(serviceItemList); 
      } 

      constraint = constraint.toString().toLowerCase(); 

      Log.d(TAG, "To Compare:: " + constraint); 

      for (int l = 0; l< sItems.size(); l++) { 

       Log.d(TAG, "sItems Size:" + sItems.size()); 

       ServiceItem sItem = sItems.get(l); 
       String name = sItem.toString(); 
       Log.d(TAG, "Name: " + name); 

       if (name.startsWith(constraint.toString().toLowerCase())){ 
        Log.d(TAG, "Added: " + name); 
        filterItems.add(sItem); 
       } 

      } 
      Log.d(TAG, "Filter Item Size: " + filterItems.size()); 

      filterResults.count = filterItems.size(); 
      filterResults.values = filterItems; 

     } else { 

      synchronized (this) { 

       Log.d(TAG, "performFiltering: ORIGINAL "); 
       Log.d(TAG, "Filter Item Size: " + serviceItemList.size()); 

       filterResults.values = serviceItemList; 
       filterResults.count = serviceItemList.size(); 

      } 
     } 

     Log.d(TAG, "Count:" + filterResults.count); 

     return filterResults; 
    } 


    @SuppressWarnings("unchecked") 
    @Override 
    protected void publishResults(CharSequence constraint, FilterResults results) { 
     /*nameList is List<ServiceItem> declared in root class*/ 

     nameList = (ArrayList<ServiceItem>) results.values; 

     notifyDataSetChanged(); 
     clear(); 
     for(int i = 0, l = nameList.size(); i < l; i++) 
      add(nameList.get(i)); 
     notifyDataSetInvalidated(); 
    } 
} 

}

EditText TextWatcher code:

edtFilterText.addTextChangedListener(new TextWatcher() { 
     @Override 
     public void beforeTextChanged(CharSequence s, int start, int count, int after) { 
     } 

     @Override 
     public void onTextChanged(CharSequence s, int start, int before, int count) { 
     } 

     @Override 
     public void afterTextChanged(Editable s) { 

      Log.d("Filter", "beforeTextChanged: " +s); 
      serviceListAdapter.getFilter().filter(s.toString().toLowerCase()); 
     } 
    }); 

, je suis le résultat de la filteration seulement pour la première fois. Puis quand j'essaye de changer le contenu d'editText, il ne me montre aucun résultat dans les éléments de filtre et affiche également la taille principale de liste de serviceItems d'affichage à zéro sans articles. Aidez-moi avec ceci, j'ai déjà essayé tant de réponses mais mon résultat fonctionne de cette manière.

Answer 1

Pour vous genre d'information je l'ai eu résolu avec l'être

// Filter Class public void filter(String charText) { charText = charText.toLowerCase(Locale.getDefault()); serviceItemList.clear(); if (charText.length() == 0) { serviceItemList.addAll(nameList); } else { for (ServiceItem si : nameList) { if (si.getServiceName().toLowerCase(Locale.getDefault()).contains(charText)) { serviceItemList.add(si); } } } notifyDataSetChanged(); }

et la méthode d'appel est le même que le précédent un peu de changement,

serviceListAdapter.filter(s.toString().toLowerCase()); 

Et pour plus d'informations ce n'est pas la méthode que nous devons implémenter à partir de la classe Filter. Sa méthode manuelle qui fonctionne comme le charme.