Saisie semi-automatique - ville seulement

Question

Est-ce que quelqu'un sait comment je peux filtrer cette saisie semi-automatique, cet utilisateur ne reçoit que le nom de la ville? comme seulement: Londres, Paris et etc, sans l'autre résultat: "London Bridge", "London Eye" et etc - comme dans l'exemple. J'utilise dans l'API endroits Google Autocomplete,

donc j'utiliser ce filtre de code:

public Filter getFilter() { 
    Filter filter = new Filter() { 
     @Override 
     protected FilterResults performFiltering(CharSequence constraint) { 
      FilterResults filterResults = new FilterResults(); 
      synchronized (filterResults) { 

       if (constraint != null) { 
        getAutocomplete(constraint); 
        result = mPlaceAPI.autocomplete(constraint.toString()); 

        if (result != null) { 
         filterResults.values = result; 
         filterResults.count = result.size(); 
        } 
       } 
       return filterResults; 

et pour obtenir le seul nom de la ville:

HttpURLConnection conn = null; 
    StringBuilder jsonResults = new StringBuilder(); 

    try { 
     StringBuilder sb = new StringBuilder(PLACES_API_BASE + TYPE_AUTOCOMPLETE + OUT_JSON); 
     sb.append("?key=" + API_KEY); 
     sb.append("&types=(cities)"); 
     sb.append("&input=" + URLEncoder.encode(input, "utf8")); 

enter image description here

Merci beaucoup:

Answer 1

Je ne sais pas pourquoi vous construisez inte Demande rnet, mais si cela n'est pas nécessaire, vous pouvez utiliser l'API Google Adresses. Voici Googles guide

Dans votre application, vous devez mettre en œuvre quelques pas:

1) Créer et connecter google API client

googleApiClient = new GoogleApiClient.Builder(Activity.this) 
      .addApi(Places.GEO_DATA_API) 
      .build(); 
    googleApiClient.connect(); 

2) Ensuite, vous avez quelques façons comment faire: utilisez l'intention de saisie semi-automatique, placezAutocompleteFragment ou créez PendingResult<AutocompletePredictionBuffer>, obtenez des résultats et utilisez-le où vous voulez. Je devais utiliser dernier, donc je créé AutocompleteFilter

AutocompleteFilter.Builder builder = new AutocompleteFilter.Builder() 
.setTypeFilter(AutocompleteFilter.TYPE_FILTER_CITIES); 

Vous pouvez voir les constantes AutocompleteFilter here Je crée PendingResult

PendingResult<AutocompletePredictionBuffer> result 
         = Places 
         .GeoDataApi 
         .getAutocompletePredictions(googleApiClient, charSequence.toString(), null, builder.build()); 

Et fait ce que je devais en rappel

result.setResultCallback(new ResultCallback<AutocompletePredictionBuffer>{...}); 

En rappel, vous pouvez recevoir des informations de la façon suivante:

Status status = autocompletePredictions.getStatus(); 
        Handler handler = new Handler(); 
        int size = autocompletePredictions.getCount(); 
        if (status.isSuccess()){ 
         for (int i = 0; i < size; i++){ 
          //Do what you need 
         } 
        } 

Peut-être que ce n'est pas le meilleur moyen mais cela fonctionne pour moi et c'est similaire à des demandes de construction, comme vous l'avez fait (à mon avis). Quoi qu'il en soit, vous pouvez trouver le meilleur pour vous dans guide. J'espère que je vous ai aidé et désolé si je perds votre temps.

Answer 2

c'est mon code, je dois me ville onlt des résultats API autocomlete lieux google: Le MainActivity:

protected synchronized void buildGoogleApiClient() { 
    mGoogleApiClient = new GoogleApiClient.Builder(this) 
      .addConnectionCallbacks(this) 
      .addOnConnectionFailedListener(this) 
      .addApi(LocationServices.API) 
      .addApi(Places.GEO_DATA_API) 
      .build(); 

} 

@Override 
public void onConnected(Bundle bundle) { 
} 

@Override 
public void onConnectionSuspended(int i) { 
} 

@Override 
public void onConnectionFailed(ConnectionResult connectionResult) { 
} 

public void searchPlace(final Editable editable) { 

    runOnUiThread(new Runnable() { 
     @Override 
     public void run() { 
      if (!editable.toString().equals("") && mGoogleApiClient.isConnected()) { 
       try { 
        mAutoCompleteAdapter.getFilter().filter(editable.toString()); 

       } catch (Exception e) { 
        Log.e(TAG, "Exception"); 

L'autre activité: PlaceAPI

public ArrayList<String> autocomplete (String input) { 
    ArrayList<String> resultList = null; 

    HttpURLConnection conn = null; 
    StringBuilder jsonResults = new StringBuilder(); 

    try { 
     StringBuilder sb = new StringBuilder(PLACES_API_BASE + TYPE_AUTOCOMPLETE + OUT_JSON); 
     sb.append("?key=" + API_KEY); 
     sb.append("&types=(cities)"); 
     sb.append("&input=" + URLEncoder.encode(input, "utf8")); 

     URL url = new URL(sb.toString()); 
     conn = (HttpURLConnection) url.openConnection(); 
     InputStreamReader in = new InputStreamReader(conn.getInputStream()); 

L'adaptateur:

private ArrayList<String> result; 


@Override 
public Filter getFilter() { 
    Filter filter = new Filter() { 
     @Override 
     protected FilterResults performFiltering(CharSequence constraint) { 
      FilterResults filterResults = new FilterResults(); 
      synchronized (filterResults) { 

       if (constraint != null) { 
        getAutocomplete(constraint); 
        result = mPlaceAPI.autocomplete(constraint.toString()); 

        if (result != null) { 
         filterResults.values = result; 
         filterResults.count = result.size(); 
        } 
       } 
       return filterResults; 
      } 
     } 


     @Override 
     protected void publishResults(CharSequence constraint, final FilterResults filterResults) { 
      synchronized (filterResults) { 

       mActivity.runOnUiThread(new Runnable() { 
        @Override 
        public void run() { 
         if (filterResults != null && filterResults.count >= 0) { 
          mResultList = resultList; 
          notifyDataSetChanged(); 
         } else { 
          notifyDataSetInvalidated(); 
         } 
        } 
       }); 

      } 

     } 
    }; 

    return filter; 
} 

C'est ce que j'ajoute à AutocompletePredictionBuffer :

private ArrayList<PlaceAutocomplete> getAutocomplete(CharSequence constraint) { 

    if (mGoogleApiClient.isConnected()) { 

     PendingResult<AutocompletePredictionBuffer> results = 
       Places.GeoDataApi.getAutocompletePredictions(mGoogleApiClient, constraint.toString(), 
         mBounds, mPlaceFilter); 


     AutocompletePredictionBuffer autocompletePredictions = results.await(60, TimeUnit.SECONDS); 
     final Status status = autocompletePredictions.getStatus(); 

     if (!status.isSuccess()) { 
      if (!mGoogleApiClient.isConnected()) { 
       mGoogleApiClient.connect(); 
      } 
      autocompletePredictions.release(); 

      return new ArrayList<>(); 
     }