Android 简易版天气预报app的实现（改进版）

需要技术支持的可以联系我QQ：1990724437

最近总是有人来和我说我以前写的一个小app无法正常获取数据~Android简易版天气预报app
今天就又运行了下来查找问题，发现或许是接口有限制吧，不能在多台手机使用同个apikey
然后，发现了我写的代码实在乱七八糟，界面也实在不好看，就又重写了一遍，小小地修改了一遍，开发环境改为了Android Studio
最终效果图如下

工程图如下

##一、获取地区信息

做这么一个天气预报app，首先就要获取到国内地区列表
（在我的另一篇博客有介绍：向任意网址发起数据请求）
中国天气网开放有天气预报接口，访问“Http://www.weather.com.cn/data/list3/city.xml”就可以获取到国内省份列表以及其代号了

如果想要获取广东省下的城市列表，由上图可知广东省的代号为28，则接口地址是 “http://www.weather.com.cn/data/list3/city28.xml”，获取到的城市列表及代号如下：

依次类推还可以获取到更加详细的地区信息，这样就完成了开头部分

##二、天气信息的获取

百度的APIStore拥有丰富的接口，涵盖了生活的许多方面。例如，我们就可以通过APIStore的某个接口获取到含有天气信息的JSON数据，从而实现天气预报功能
(在我的另一篇博客有介绍：获取含天气信息的jsON数据)
首先，使用者要有一个百度账号，然后登陆以下网址：中国和世界天气预报
该接口是免费的，不过因此也就不够稳定，我在调试的时候就经常出错
然后在API选项下点击“您自己的apikey”，查看自己的apikey。该值是每个开发者和app的唯一标识，需要妥善保管，有了apikey才可以进行下一步的操作

获取到的天气信息是JSON格式的，需要在程序中再来解析

##三、数据库的设计
地区列表这些信息一般都是固定不变的，所以我们可以把第一次联网获取到的数据存进数据库里，下次再次访问时就从数据库里读取即可
首先要设定四个Model，包括：省份、城市、县、每小时天气预测，用来承载数据
每个Model包括几个属性以及相应的get和set方法
例如，省份Province的设计如下所示，城市City和县County的设计类似

public class Province {
	//省份名
    private String provinceName;
    //省份ID
    private String provinceId;
    public String getProvinceId() {
        return provinceId;
    }
    public String getProvinceName() {
        return provinceName;
    }
    public void setProvinceId(String provinceId) {
        this.provinceId = provinceId;
    }
    public void setProvinceName(String provinceName) {
        this.provinceName = provinceName;
    }
}

每小时天气预测HourlyWeather的设计如下：

public class HourlyWeather {
    //预测时间
    private String time;
    //温度
    private String temp;
    //降水概率
    private String pop;
    //风力
    private String wind;
    public HourlyWeather(String time, String temp, String pop, String wind) {
        this.time = time;
        this.temp = temp;
        this.pop = pop;
        this.wind = wind;
    }
    public String getTime() {
        return time;
    }
    public String getTemp() {
        return temp;
    }
    public String getPop() {
        return pop;
    }
    public String getWind() {
        return wind;
    }
}

然后，新建一个DatabaseHelper类继承于sqliteOpenHelper，用来建立三个数据库表

public class DatabaseHelper extends SQLiteOpenHelper {
    private final String CREATE_PROVINCE = "create table Province ("
            + "provinceName text," + "provinceId text )";
    private final String CREATE_CITY = "create table City("
            + "cityName text," + "cityId text," + "provinceId text)";
    private final String CREATE_COUNTY = "create table County("
            + "countyName text," + "countyId text," + "cityId text)";
    public DatabaseHelper(Context context, String DbName,
                          CursorFactory factory, int version) {
        super(context, DbName, factory, version);
    }
    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(CREATE_PROVINCE);
        db.execSQL(CREATE_CITY);
        db.execSQL(CREATE_COUNTY);
    }
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    }
}

然后，再建立一个WeatherDB类，用来进行实际的数据库操作，包括存取省份信息、城市信息、县信息等
需要注意的是，因为每个城市都是包含在某个省份下的，所以查询某个省份下的所有城市列表，需要将省份的ID传入作为唯一标识

public class WeatherDB {
    private final String DataBaseName = "ZyWeather";
    private final int VERSION = 1;
    private SQLiteDatabase database;
    private static WeatherDB weatherDB;
    private WeatherDB(Context context) {
        DatabaseHelper dataBaseHelper = new DatabaseHelper(context,
                DataBaseName, null, VERSION);
        database = dataBaseHelper.getWritableDatabase();
    }
    //获取实例
    public static WeatherDB getInstance(Context context) {
        if (weatherDB == null) {
            weatherDB = new WeatherDB(context);
        }
        return weatherDB;
    }
    //保存省份信息
    public void saveProvinces(List provinceList) {
        if (provinceList != null && provinceList.size() > 0) {
            ContentValues values = new ContentValues();
            for (int i = 0; i < provinceList.size(); i++) {
                values.put("provinceName", provinceList.get(i).getProvinceName());
                values.put("provinceId", provinceList.get(i).getProvinceId());
                database.insert("Province", null, values);
                values.clear();
            }
        }
    }
    //保存城市信息
    public void saveCities(List cityList) {
        if (cityList != null && cityList.size() > 0) {
            ContentValues values = new ContentValues();
            for (int i = 0; i < cityList.size(); i++) {
                values.put("cityName", cityList.get(i).getCityName());
                values.put("cityId", cityList.get(i).getCityId());
                values.put("provinceId", cityList.get(i).getProvinceId());
                database.insert("City", null, values);
                values.clear();
            }
        }
    }
    //保存乡村信息
    public void saveCounties(List countyList) {
        if (countyList != null && countyList.size() > 0) {
            ContentValues values = new ContentValues();
            for (int i = 0; i < countyList.size(); i++) {
                values.put("countyName", countyList.get(i).getCountyName());
                values.put("countyId", countyList.get(i).getCountyId());
                values.put("cityId", countyList.get(i).getCityId());
                database.insert("County", null, values);
                values.clear();
            }
        }
    }
    //返回所有省份信息
    public List getAllProvince() {
        Cursor cursor = database.query("Province", null, null, null, null, null, null);
        List list = new ArrayList();
        Province province;
        if (cursor.moveToFirst()) {
            do {
                province = new Province();
                province.setProvinceName(cursor.getString(cursor.getColumnIndex("provinceName")));
                province.setProvinceId(cursor.getString(cursor.getColumnIndex("provinceId")));
                list.add(province);
            } while (cursor.moveToNext());
        }
        return list;
    }
    //返回指定省份下的所有城市
    public List getAllCity(String provinceId) {
        List list = new ArrayList();
        City city;
        Cursor cursor = database.query("City", null, "provinceId = ?", new String[]{provinceId}, null, null, null);
        if (cursor.moveToFirst()) {
            do {
                city = new City();
                city.setCityName(cursor.getString(cursor.getColumnIndex("cityName")));
                city.setCityId(cursor.getString(cursor.getColumnIndex("cityId")));
                city.setProvinceId(provinceId);
                list.add(city);
            } while (cursor.moveToNext());
        }
        return list;
    }
    //返回指定城市下的所有乡村
    public List getAllCountry(String cityId) {
        List list = new ArrayList();
        Cursor cursor = database.query("County", null, "cityId=?", new String[]{cityId}, null, null, null);
        County county;
        if (cursor.moveToFirst()) {
            do {
                county = new County();
                county.setCountyName(cursor.getString(cursor.getColumnIndex("countyName")));
                county.setCountyId(cursor.getString(cursor.getColumnIndex("countyId")));
                county.setCityId(cityId);
                list.add(county);
            } while (cursor.moveToNext());
        }
        return list;
    }
}

##四、联网操作

整个app用同一个函数来完成各种数据数据操作，该函数包含在HttpUtil类下，为静态函数
当中需要填入自己申请的apikey，该key仅在获取天气信息时有用，在获取地区信息时是不需要的，这里只是为了简便，所以就一起写上了

public class HttpUtil {
    public static void sendHttpRequest(final String address, final HttpCallbackListener listener) {
        new Thread(new Runnable() {
            public void run() {
                HttpURLConnection connection = null;
                try {
                    URL url = new URL(address);
                    connection = (HttpURLConnection) url.openConnection();
                    connection.setRequestMethod("GET");
                    connection.setConnectTimeout(8000);
                    connection.setReadTimeout(8000);
                    connection.setRequestProperty("apikey", "填入自己的apikey");
                    connection.connect();
                    InputStream inputStream = connection.getInputStream();
                    InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
                    BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
                    StringBuilder response = new StringBuilder();
                    String line;
                    while ((line = bufferedReader.readLine()) != null) {
                        response.append(line);
                    }
                    if (listener != null) {
                        listener.onFinish(response.toString());
                    }
                } catch (Exception e) {
                    if (listener != null) {
                        listener.onError(e);
                    }
                } finally {
                    if (connection != null) {
                        connection.disconnect();
                    }
                }
            }
        }).start();
    }
}

##五、工具类
在联网访问数据成功或失败后，都需要通过回调方法进行数据处理，所以需要设定一个接口HttpCallbackListener

public interface HttpCallbackListener {
    void onFinish(String response);
    void onError(Exception e);
}

此外，使用HttpUtil 类获取到地区信息后，因为数据包含一些分隔符，无法直接存入数据库，而且获取到的天气信息也是JSON格式的，也需要进行数据解析，所以还需要有一个Utility类用来进行数据处理

public class Utility {
    // 保存服务器返回的省级数据
    public static boolean saveProvincesResponse(WeatherDB weatherDB, String response) {
        if (!TextUtils.isEmpty(response)) {
            String[] allProvinces = response.split(",");
            if (allProvinces != null && allProvinces.length > 0) {
                Province province;
                List provinceList = new ArrayList();
                for (String p : allProvinces) {
                    String[] array = p.split("\\|");
                    province = new Province();
                    province.setProvinceId(array[0]);
                    province.setProvinceName(array[1]);
                    provinceList.add(province);
                }
                weatherDB.saveProvinces(provinceList);
                return true;
            }
        }
        return false;
    }
    // 保存服务器返回的市级数据
    public static boolean saveCitiesResponse(WeatherDB weatherDB, String response, String provinceId) {
        if (!TextUtils.isEmpty(response)) {
            String[] allCities = response.split(",");
            if (allCities != null && allCities.length > 0) {
                City city;
                List cityList = new ArrayList();
                for (String c : allCities) {
                    String[] array = c.split("\\|");
                    city = new City();
                    city.setCityId(array[0]);
                    city.setCityName(array[1]);
                    city.setProvinceId(provinceId);
                    cityList.add(city);
                }
                weatherDB.saveCities(cityList);
                return true;
            }
        }
        return false;
    }
    // 保存服务器返回的县级数据
    public static boolean saveCountiesResponse(WeatherDB weatherDB, String response, String cityId) {
        if (!TextUtils.isEmpty(response)) {
            String[] allCounties = response.split(",");
            if (allCounties != null && allCounties.length > 0) {
                County county;
                List countyList = new ArrayList();
                for (String c : allCounties) {
                    String[] array = c.split("\\|");
                    county = new County();
                    county.setCountyId(array[0]);
                    county.setCountyName(array[1]);
                    county.setCityId(cityId);
                    countyList.add(county);
                }
                weatherDB.saveCounties(countyList);
                return true;
            }
        }
        return false;
    }
    // 处理服务器返回的json数据
    public static void handleWeatherResponse(Context context, String response) {
        try {
            JSONObject jsonobject = new JSONObject(response);
            JSONArray title = jsonobject.getJSONArray("HeWeather data service 3.0");
            JSONObject first_object = (JSONObject) title.get(0);
            JSONObject basic = (JSONObject) first_object.get("basic");
            //更新时间
            JSONObject update = (JSONObject) basic.get("update");
            JSONArray daily_forecast = (JSONArray) first_object.get("daily_forecast");
            JSONObject daily_forecast_first = (JSONObject) daily_forecast.get(0);
            JSONObject cond = (JSONObject) daily_forecast_first.get("cond");
            //温度
            JSONObject temp = (JSONObject) daily_forecast_first.get("tmp");
            JSONObject astro = (JSONObject) daily_forecast_first.get("astro");
            JSONObject wind = (JSONObject) daily_forecast_first.get("wind");
            JSONArray hourly_forecast = (JSONArray) first_object.get("hourly_forecast");
            WeatherActivity.weatherList.clear();
            for (int i = 0; i < hourly_forecast.length(); i++) {
                JSONObject json = hourly_forecast.getJSONObject(i);
                JSONObject json_wind = (JSONObject) json.get("wind");
                String date = json.getString("date");
                String[] array = date.split(" ");
                String dir = json_wind.getString("dir");
                String sc = json_wind.getString("sc");
                String hourly_clock = array[1];
                String hourly_temp = "温度：" + json.getString("tmp") + "℃";
                String hourly_pop = "降水概率：" + json.getString("pop");
                String hourly_wind = "风力：" + dir + " " + sc + "级";
                HourlyWeather weather = new HourlyWeather(hourly_clock, hourly_temp, hourly_pop, hourly_wind);
                WeatherActivity.weatherList.add(weather);
            }
            //日出
            String sunriseTime = astro.getString("sr");
            //日落
            String sunsetTime = astro.getString("ss");
            //白天天气
            String dayWeather = cond.getString("txt_d");
            //夜晚天气
            String nightWeather = cond.getString("txt_n");
            //风力
            String windText = wind.getString("dir") + " " + wind.getString("sc") + "级";
            //降水概率
            String pop = daily_forecast_first.getString("pop");
            //温度
            String tempText = temp.getString("min") + "℃~" + temp.getString("max") + "℃";
            //更新时间
            String updateTime = update.getString("loc");
            //城市名
            String cityName = basic.getString("city");
            saveWeatherInfo(context, cityName, sunriseTime, sunsetTime, dayWeather, nightWeather, windText, pop, tempText, updateTime);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private static void saveWeatherInfo(Context context, String cityName,
                                        String sunriseTime, String sunsetTime, String dayWeather, String nightWeather,
                                        String windText, String pop, String tempText, String updateTime) {
        SharedPreferences.Editor editor = context.getSharedPreferences("Weather", Context.MODE_PRIVATE).edit();
        editor.putString("cityName", cityName);
        editor.putString("sunriseTime", sunriseTime);
        editor.putString("sunsetTime", sunsetTime);
        editor.putString("dayWeather", dayWeather);
        editor.putString("nightWeather", nightWeather);
        editor.putString("wind", windText);
        editor.putString("pop", pop);
        editor.putString("temp", tempText);
        editor.putString("updateTime", updateTime);
        editor.commit();
    }
}

##六、适配器
由上边的动态图可以看到每小时的天气预测信息，那是使用ListView呈现的，这就要为其提供一个适配器了
ListView使用的布局文件如下：

然后新建一个WeatherAdapter继承于ArrayAdapter
只要重写

getView(int position, View convertView, ViewGroup parent)

方法即可

public class WeatherAdapter extends ArrayAdapter {
    private int resourceId;
    private Context context;
    public WeatherAdapter(Context context, int textViewResourceId, List objects) {
        super(context, textViewResourceId, objects);
        this.context = context;
        this.resourceId = textViewResourceId;
    }
    public View getView(int position, View convertView, ViewGroup parent) {
        HourlyWeather weather = getItem(position);
        View view = LayoutInflater.from(context).inflate(resourceId, null);
        TextView forecastTime = (TextView) view.findViewById(R.id.forecastTime);
        TextView forecastTemp = (TextView) view.findViewById(R.id.forecastTemp);
        TextView forecastPop = (TextView) view.findViewById(R.id.forecastPop);
        TextView forecastWind = (TextView) view.findViewById(R.id.forecastWind);
        forecastTime.setText(weather.getTime());
        forecastTemp.setText(weather.getTemp());
        forecastPop.setText(weather.getPop());
        forecastWind.setText(weather.getWind());
        return view;
    }
}

##七、Activity的编写
首先要完成地区选择界面ChooseAreaActivity
ChooseAreaActivity的界面仅包括一个居中的TextView和一个ListView
布局文件如下：

ChooseAreaActivity 需要完成的操作有：完成地区列表的加载、将选择的County名传递给WeatherActivity
此外，当中使用了showProgressDialog()来呈现一个进度对话框，也设为无法通过返回键关闭，而我又没有在弱网环境下调试过，每次加载都是很快，也没见到对话框出来过，所以也不知道showProgressDialog()到底有没有bug啥的~

public class ChooseAreaActivity extends AppCompatActivity {
    // 标记当前列表为省份
    public static final int LEVEL_PROVINCE = 0;
    // 标记当前列表为城市
    public static final int LEVEL_CITY = 1;
    // 标记当前列表为县
    public static final int LEVEL_COUNTY = 2;
    // 进度对话框
    private ProgressDialog progressDialog;
    // 标题栏
    private TextView titleText;
    // 数据列表
    private ListView listView;
    // 列表数据
    private ArrayAdapter adapter;
    // 数据库
    private WeatherDB weatherDB;
    private List dataList;
    private List provinceList;
    private List cityList;
    private List countyList;
    //选择的省份
    private Province selectedProvince;
    //选择的城市
    private City selectedCity;
    //当前选择的列表类型
    private int currentLevel;
    //标记是否从WeatherActivity跳转而来的
    private boolean isFromWeatherActivity;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        isFromWeatherActivity = getIntent().getBooleanExtra("ChooseArea", false);
        SharedPreferences sharedPreferences = getSharedPreferences("Weather", Context.MODE_PRIVATE);
        // 如果country已选择且本Activity不是从天气界面启动而来的，则直接跳转到WeatherActivity
        if (!TextUtils.isEmpty(sharedPreferences.getString("CountyName", "")) && !isFromWeatherActivity) {
            Intent intent = new Intent(this, WeatherActivity.class);
            startActivity(intent);
            finish();
            return;
        }
        setContentView(R.layout.activity_choose_area);
        if (getSupportActionBar() != null) {
            getSupportActionBar().hide();
        }
        listView = (ListView) findViewById(R.id.listView);
        titleText = (TextView) findViewById(R.id.title);
        dataList = new ArrayList();
        adapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1, dataList);
        listView.setAdapter(adapter);
        weatherDB = WeatherDB.getInstance(this);
        listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView arg0, View arg1, int index, long arg3) {
                if (currentLevel == LEVEL_PROVINCE) {
                    selectedProvince = provinceList.get(index);
                    queryCities();
                } else if (currentLevel == LEVEL_CITY) {
                    selectedCity = cityList.get(index);
                    queryCounties();
                } else if (currentLevel == LEVEL_COUNTY) {
                    //当点击到县列表时，就利用Intent跳转到天气信息界面
                    String countyName = countyList.get(index).getCountyName();
                    Intent intent = new Intent(ChooseAreaActivity.this, WeatherActivity.class);
                    intent.putExtra("CountyName", countyName);
                    startActivity(intent);
                    finish();
                }
            }
        });
        queryProvinces();
    }
    private void queryProvinces() {
        showProgressDialog();
        provinceList = weatherDB.getAllProvince();
        if (provinceList.size() > 0) {
            dataList.clear();
            for (Province province : provinceList) {
                dataList.add(province.getProvinceName());
            }
            adapter.notifyDataSetChanged();
            listView.setSelection(0);
            titleText.setText("中国");
            currentLevel = LEVEL_PROVINCE;
            closeProgressDialog();
        } else {
            queryFromServer(null, "province");
        }
    }
    private void queryCities() {
        showProgressDialog();
        cityList = weatherDB.getAllCity(selectedProvince.getProvinceId());
        if (cityList.size() > 0) {
            dataList.clear();
            for (City city : cityList) {
                dataList.add(city.getCityName());
            }
            adapter.notifyDataSetChanged();
            listView.setSelection(0);
            titleText.setText(selectedProvince.getProvinceName());
            currentLevel = LEVEL_CITY;
            closeProgressDialog();
        } else {
            queryFromServer(selectedProvince.getProvinceId(), "city");
        }
    }
    private void queryCounties() {
        showProgressDialog();
        countyList = weatherDB.getAllCountry(selectedCity.getCityId());
        if (countyList.size() > 0) {
            dataList.clear();
            for (County county : countyList) {
                dataList.add(county.getCountyName());
            }
            adapter.notifyDataSetChanged();
            listView.setSelection(0);
            titleText.setText(selectedCity.getCityName());
            currentLevel = LEVEL_COUNTY;
            closeProgressDialog();
        } else {
            queryFromServer(selectedCity.getCityId(), "county");
        }
    }
    private void queryFromServer(final String code, final String type) {
        String address;
        // code不为空
        if (!TextUtils.isEmpty(code)) {
            address = "http://www.weather.com.cn/data/list3/city" + code + ".xml";
        } else {
            address = "http://www.weather.com.cn/data/list3/city.xml";
        }
        HttpUtil.sendHttpRequest(address, new HttpCallbackListener() {
            @Override
            public void onFinish(String response) {
                boolean result = false;
                if ("province".equals(type)) {
                    result = Utility.saveProvincesResponse(weatherDB, response);
                } else if ("city".equals(type)) {
                    result = Utility.saveCitiesResponse(weatherDB, response, selectedProvince.getProvinceId());
                } else if ("county".equals(type)) {
                    result = Utility.saveCountiesResponse(weatherDB, response, selectedCity.getCityId());
                }
                if (result) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            if ("province".equals(type)) {
                                queryProvinces();
                            } else if ("city".equals(type)) {
                                queryCities();
                            } else if ("county".equals(type)) {
                                queryCounties();
                            }
                        }
                    });
                }
            }
            @Override
            public void onError(Exception e) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        Toast.makeText(ChooseAreaActivity.this, "加载失败", Toast.LENGTH_SHORT).show();
                    }
                });
            }
        });
        closeProgressDialog();
    }
    private void showProgressDialog() {
        if (progressDialog == null) {
            progressDialog = new ProgressDialog(this);
            progressDialog.setMessage("正在加载……");
            progressDialog.setCanceledOnTouchOutside(false);
        }
        progressDialog.show();
    }
    private void closeProgressDialog() {
        if (progressDialog != null) {
            progressDialog.dismiss();
        }
    }
    @Override
    public void onBackPressed() {
        if (currentLevel == LEVEL_COUNTY) {
            queryCities();
        } else if (currentLevel == LEVEL_CITY) {
            queryProvinces();
        } else {
            if (isFromWeatherActivity) {
                Intent intent = new Intent(this, WeatherActivity.class);
                startActivity(intent);
            }
            finish();
        }
    }
}

WeatherActivity的布局相对复杂些，包含了许多个TextView，我也只是想着简单就好，就简单地把数据用文本呈现出来

// 城市切换按钮
    private Button citySwitch;
    // 刷新数据按钮
    private Button weatherRefresh;
    // 城市名
    private TextView cityName;
    // 白天夜晚天气描叙
    private TextView DayNightWeather;
    // 温度
    private TextView temp;
    // 日出时间
    private TextView sunriseTime;
    // 日落时间
    private TextView sunsetTime;
    // 风力
    private TextView wind;
    // 降水概率
    private TextView pop;
    // 发布时间
    private TextView updateTime;
    // 今日天气预测列表
    private ListView listview;
    public static List weatherList = new ArrayList();
    private SharedPreferences sharedPreferences;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.weather);
        if (getSupportActionBar() != null) {
            getSupportActionBar().hide();
        }
        init();
    }
    private void init() {
        citySwitch = (Button) findViewById(R.id.citySwitch);
        weatherRefresh = (Button) findViewById(R.id.weatherRefresh);
        citySwitch.setOnClickListener(this);
        weatherRefresh.setOnClickListener(this);
        cityName = (TextView) findViewById(R.id.cityName);
        DayNightWeather = (TextView) findViewById(R.id.DayNightWeather);
        temp = (TextView) findViewById(R.id.temp);
        sunriseTime = (TextView) findViewById(R.id.sunriseTime);
        sunsetTime = (TextView) findViewById(R.id.sunsetTime);
        wind = (TextView) findViewById(R.id.wind);
        pop = (TextView) findViewById(R.id.pop);
        updateTime = (TextView) findViewById(R.id.updateTime);
        listview = (ListView) findViewById(R.id.hourlyForecast);
        sharedPreferences = getSharedPreferences("Weather", Context.MODE_PRIVATE);
        String countyName = getIntent().getStringExtra("CountyName");
        // 当countyName不为空
        if (!TextUtils.isEmpty(countyName)) {
            SharedPreferences.Editor editor = sharedPreferences.edit();
            editor.putString("CountyName", countyName);
            editor.commit();
        } else {
            countyName = sharedPreferences.getString("CountyName", "");
        }
        weatherRefresh.setText("同步中……");
        queryFromServer(countyName);
    }
    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.citySwitch:
                Intent intent = new Intent(this, ChooseAreaActivity.class);
                intent.putExtra("ChooseArea", true);
                startActivity(intent);
                finish();
                break;
            case R.id.weatherRefresh:
                weatherRefresh.setText("同步中……");
                String countyName = sharedPreferences.getString("CountyName", "");
                if (!TextUtils.isEmpty(countyName)) {
                    queryFromServer(countyName);
                }
                break;
        }
    }
    private void queryFromServer(final String countyName) {
        try {
            String url = "http://apis.baidu.com/heweather/weather/free?city=";
            String name = new String(countyName.getBytes("UTF-8"), "iso-8859-1");
            HttpUtil.sendHttpRequest(url + name, new HttpCallbackListener() {
                @Override
                public void onFinish(String response) {
                    Utility.handleWeatherResponse(WeatherActivity.this, response);
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            showWeather();
                        }
                    });
                }
                @Override
                public void onError(Exception e) {
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            Toast.makeText(WeatherActivity.this, "同步失败", Toast.LENGTH_LONG).show();
                            weatherRefresh.setText("更新数据");
                        }
                    });
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private void showWeather() {
        cityName.setText(sharedPreferences.getString("cityName", "未知"));
        sunriseTime.setText("日出：" + sharedPreferences.getString("sunriseTime", "未知"));
        sunsetTime.setText("日落：" + sharedPreferences.getString("sunsetTime", "未知"));
        DayNightWeather.setText("日：" + sharedPreferences.getString("dayWeather", "未知") + " 夜：" + sharedPreferences.getString("nightWeather", "未知"));
        temp.setText("温度：" + sharedPreferences.getString("temp", "未知"));
        wind.setText("风力：" + sharedPreferences.getString("wind", "未知"));
        pop.setText("降水概率：" + sharedPreferences.getString("pop", "未知"));
        updateTime.setText("发布时间:" + sharedPreferences.getString("updateTime", "未知"));
        WeatherAdapter adapter = new WeatherAdapter(this, R.layout.hourly_weather, weatherList);
        listview.setAdapter(adapter);
        Toast.makeText(WeatherActivity.this, "已经是最新数据了", Toast.LENGTH_SHORT).show();
        weatherRefresh.setText("更新数据");
    }
}

##八、说明
很奇怪的是，这个小app在我的4.4版本的小米手机上运行无误，可在5.1系统的模拟器和华为手机上却提示无法获取到数据，返回的JSON数据提示说城市未知，查看了很久也没搞明白，只能作罢~~

代码下载地址：Android简易版天气预报app的实现（改进版）

作者：叶志陈_