如何在调用PokéAPI时异步更新ListView？

Great question! Your initial approach using pagination via the next/previous endpoints and async operations is spot-on—let's refine this into a robust, user-friendly solution.

First, Validate Your Core Idea #

Using async tasks to fetch data in the background and update the ListView incrementally is exactly the right direction. The key here is to avoid blocking the UI thread while fetching data, and to feed new items to the ListView as they arrive (or in batches, since PokeAPI returns paginated results).

Step-by-Step Refined Implementation #

1. Encapsulate PokeAPI Fetch Logic

First, create a helper class to handle API calls and response parsing—this keeps your async code clean and reusable:

public class PokeApiHelper {
    public static PokemonListResponse fetchPokemonList(String url) throws IOException {
        // Use OkHttp for reliable network requests (you could also use HttpURLConnection)
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder().url(url).build();
        Response response = client.newCall(request).execute();
        
        if (!response.isSuccessful()) throw new IOException("Request failed: " + response.code());
        
        // Parse JSON into a model class with Gson (or Moshi)
        Gson gson = new Gson();
        return gson.fromJson(response.body().string(), PokemonListResponse.class);
    }
    
    // Model classes to map the API response
    public static class PokemonListResponse {
        public String next;
        public String previous;
        public List<PokemonEntry> results;
        
        public static class PokemonEntry {
            public String name;
            public String url;
        }
    }
}

2. AsyncTask with Progress Updates

Instead of waiting for all data to load, use publishProgress() to send batches of Pokemon entries to the UI thread as they're fetched. This lets your ListView update incrementally:

public class PokemonFetchTask extends AsyncTask<String, List<PokeApiHelper.PokemonEntry>, Void> {
    private WeakReference<ListView> listViewWeakRef;
    private ArrayAdapter<String> adapter;
    private String nextUrl;
    public boolean isLoading = false;

    public PokemonFetchTask(ListView listView, ArrayAdapter<String> adapter) {
        this.listViewWeakRef = new WeakReference<>(listView);
        this.adapter = adapter;
    }

    @Override
    protected Void doInBackground(String... urls) {
        try {
            String currentUrl = urls[0];
            while (currentUrl != null && !isCancelled()) {
                PokeApiHelper.PokemonListResponse response = PokeApiHelper.fetchPokemonList(currentUrl);
                nextUrl = response.next;
                
                // Send the batch of results to update the UI
                publishProgress(response.results);
                
                // Add a small delay to respect PokeAPI's rate limits
                Thread.sleep(500);
                
                currentUrl = nextUrl;
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
            // Optional: Publish an error state to show a toast to the user
        }
        return null;
    }

    @Override
    protected void onProgressUpdate(List<PokeApiHelper.PokemonEntry>... values) {
        super.onProgressUpdate(values);
        ListView listView = listViewWeakRef.get();
        if (listView == null) return;
        
        // Add new entries to the adapter and refresh the ListView
        for (PokeApiHelper.PokemonEntry entry : values[0]) {
            adapter.add(entry.name);
        }
        adapter.notifyDataSetChanged();
        isLoading = false;
    }

    public String getNextUrl() {
        return nextUrl;
    }
}

3. Trigger Pagination on ListView Scroll

Add a scroll listener to load the next page when the user reaches the bottom of the ListView:

ListView pokemonListView = findViewById(R.id.pokemon_list);
ArrayAdapter<String> adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1);
pokemonListView.setAdapter(adapter);

// Start with the initial API endpoint
PokemonFetchTask currentTask = new PokemonFetchTask(pokemonListView, adapter);
currentTask.execute("https://pokeapi.co/api/v2/pokemon/");

pokemonListView.setOnScrollListener(new AbsListView.OnScrollListener() {
    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {}

    @Override
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
        // Load next page when user scrolls to the bottom and no ongoing request
        if (firstVisibleItem + visibleItemCount >= totalItemCount && totalItemCount != 0 && !currentTask.isLoading()) {
            currentTask.isLoading = true;
            String nextUrl = currentTask.getNextUrl();
            if (nextUrl != null) {
                currentTask = new PokemonFetchTask(pokemonListView, adapter);
                currentTask.execute(nextUrl);
            }
        }
    }
});

Critical Improvements & Best Practices #

• Avoid Memory Leaks: Use WeakReference for the ListView and adapter in the AsyncTask to prevent holding onto activity references after it's destroyed.
• Respect Rate Limits: PokeAPI has rate limits, so adding small delays between requests prevents you from getting blocked.
• Error Handling: Extend the code to show a toast or error message if the API request fails (e.g., publish an error signal via publishProgress).
• Modern Alternatives: AsyncTask is deprecated in newer Android versions. For a more robust solution, use Kotlin Coroutines + ViewModel + LiveData:
  • Use viewModelScope.launch to run background tasks tied to the ViewModel's lifecycle.
  • Use LiveData to observe data changes and update the ListView automatically without manual notifyDataSetChanged calls.

Final Notes #

Your initial thought to use onProgressUpdate for UI updates is perfect—it's designed exactly for sending intermediate results from the background thread to the UI thread. By combining this with scroll-triggered pagination, you'll get a smooth, responsive experience even with PokeAPI's slower response times.

内容的提问来源于stack exchange，提问作者JaviBear