标签 安卓 下的文章

方法重载与覆盖的区别

方法的重载属于编译时多态,方法名相同参数列表不同,返回值必须相同或都没有返回值类型。方法的覆盖属于运行时多态,子类覆盖父类的方法,子类指向父类引用,在调用方法的时候用父类的引用调用。

String 和StringBuffer的区别

String的长度是不可变的,StringBuffer的长度是可变的。如果你对字符串中的内容经常进行操作,特别是内容要修改时,那么使用StringBuffer,如果最后需要String,那么使用StringBuffer的toString()方法。
字符串“abcde”通过写一个函数不让调用第三方的字符串,实现一个字符串倒序,比如字符串“abcde” 变成“edcba”
String src = "ABCDEF ";
String dst = new StringBuffer(src).reverse().toString();

抽象类与接口的区别

abstract可以修饰抽象方法,而一个类只要有一个抽象方法,就必须用abstract定义该类,即抽象类。
用interface修饰的类,里面的方法都是抽象方法,因此在定义接口的时候,可以直接不加那些修饰,系统会默认的添上去。接口里面的字段都是公有常量,即public static final修饰的字段。

线程有几种状态,分别是哪些

1)、新建状态(New):新创建了一个线程对象。
2)、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。
3)、运行状态(Running):就绪状态的线程获取了CPU,执行run()方法。
4)、阻塞状态(Blocked):阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:
(一)、等待阻塞:运行的线程执行wait()方法,JVM会把该线程放入等待池中。
(二)、同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入锁池中。
(三)、其他阻塞:运行的线程执行sleep()或join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
5)、死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
当调用start方法的时候,该线程就进入就绪状态。等待CPU进行调度执行,此时还没有真正执行线程。
当调用run方法的时候,是已经被CPU进行调度,执行线程的主要任务。

线程的实现方式

线程的实现有两种方式,一是继承Thread类,二是实现Runnable接口

final、finally、finanlize()的区别

final用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承。
finally是异常处理语句结构的一部分,表示总是执行。
finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提供垃圾收集时的其他资源回收,例如关闭文件等。

常用设计模式及应用场景

单例模式: Calendar实例的获取
适配器模式: Adapter为ListView GridView等添加数据
工厂模式: Spring IOC 反转控制
代理模式: Spring AOP 面向切面编程
观察者模式: ContentObserver监听内容改变

用两种方式实现单例模式,要求线程安全

(懒汉式)程序执行过程中需要这个类的对象时再实例化该类的对象
步骤1.定义静态私有对象
2. 构造方法私有化保证在类的外部无法实例化该类的对象
3. 定义对外开放的静态方法在调用方法是判断对象是否为空,为空再创建对象返回
public class Singleton {
private static Singleton singleton;
// 构造方法私有化,保证在类的外部无法实例化该类的对象
private Singleton() {
}
public static synchronized Singleton getSingletonInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
(饿汉式)类加载的时候就实例化该类的对象
public class Singleton {
private static Singleton singleton = new Singleton();
// 构造方法私有化,保证在类的外部无法实例化该类的对象
private Singleton() {
}
public static Singleton getSingletonInstance() {
return singleton;
}
}

Android系统架构

1)应用程序层 java语言 应用程序开发
2)应用程序框架层 java语言 OS定制 framework层开发
3)系统运行库层 C C++ 实现 so库
4)Linux内核层

Activity生命周期

void onCreate(Bundle savedInstanceState) 第一次创建时调用
void onStart() 被用户可见时调用
void onRestart() 当Activity处于stop状态又被重新启动时调用
void onResume() 当获得焦点即可与用户交互时调用
void onPause() 当失去焦点时调用
void onStop() 当不可见时调用
void onDestroy() 当销毁时调用

Activity的 onSaveInstanceState() 和 onRestoreInstanceState()

Activity的 onSaveInstanceState() 和 onRestoreInstanceState()并不是生命周期方法,它们不同于 onCreate()、onPause()等生命周期方法,它们并不一定会被触发。当应用遇到意外情况(如:内存不足、用户直接按Home键)由系统销毁一个Activity时,onSaveInstanceState() 会被调用。但是当用户主动去销毁一个Activity时,例如在应用中按返回键,onSaveInstanceState()就不会被调用。因为在这种情况下,用户的行为决定了不需要保存Activity的状态。通常onSaveInstanceState()只适合用于保存一些临时性的状态,而onPause()适合用于数据的持久化保存。
另外,当屏幕的方向发生了改变, Activity会被摧毁并且被重新创建,如果你想在Activity被摧毁前缓存一些数据,并且在Activity被重新创建后恢复缓存的数据。可以重写Activity的 onSaveInstanceState() 和 onRestoreInstanceState()方法。

Android四大组件

Activity :应用程序中,一个Activity通常就是一个单独的屏幕,它上面可以显示一些控件也可以监听并处理用户的事件做出响应。Activity之间通过Intent进行通信。
Service 服务:一个Service 是一段长生命周期的,没有用户界面的程序,可以用来开发如监控类程序。
BroadcastReceive广播接收器:你的应用可以使用它对外部事件进行过滤只对感兴趣的外部事件(如当电话呼入时,或者数据网络可用时)进行接收并做出响应。广播接收器没有用户界面。然而,它们可以启动一个activity或serice 来响应它们收到的信息。
Content Provider内容提供者 :主要用于多个应用间数据共享。这些数据可以存储在文件系统中或SQLite数据库。

广播如何调用,有什么方式,各自的区别

程序中发送广播通过sendBroadcastReceiver()实现
接收广播通过定义一个类继承BroadcastReceiver并重写onReceive()方法实现
注册广播有两种方式:
第一种静态方式:在清单文件中通过标签声明
第二种代码动态方式:
IntentFilter filter = new IntentFilter("android.provider.Telephony.SMS_RECEIVED");
IncomingSMSReceiver receiver = new IncomgSMSReceiver();
registerReceiver(receiver.filter);
1)第一种不是常驻型广播,也就是说广播跟随activity的生命周期。注意: 在activity结束前,移除广播接收器。
2)第二种是常驻型,也就是说当应用程序关闭后,如果有信息广播来,程序也会被系统调用自动运行。

Android中asset文件夹和raw文件夹区别

res/raw和assets的相同点:
两者目录下的文件在打包后会原封不动的保存在apk包中,不会被编译成二进制。
res/raw和assets的不同点:
1)res/raw中的文件会被映射到R.java文件中,访问的时候直接使用资源ID即 R.raw.filename;assets文件夹下的文件不会被映射到R.java中,访问的时候需要AssetManager类。
2)res/raw不可以有目录结构,而assets则可以有目录结构,也就是assets目录下可以再建立文件夹
3)读取文件资源举例:
读取res/raw下的文件资源,通过以下方式获取输入流来进行写操作
InputStream is = getResources().openRawResource(R.raw.filename);
读取assets下的文件资源,通过以下方式获取输入流来进行写操作
AssetManager am = null;
am = getAssets();
InputStream is = am.open("filename");

Android中的五种存储方式及其应用场景

1)SharedPreferences
存储路径:(data/data/packagename/shares_prefs), 轻量级存储,以键值对的形式存储在xml中,一般用来保存应用中的设置属性
2)文件存储;opSD卡存储多媒体文件, 文件缓存
3) Sqlite数据库 存储路径:(data/data/packagename/databases), 一种嵌入式数据库,支持sql语言,存储大量结构性数据
4)ContentProvider 进程(应用程序)间数据共享,数据源可以是sqlite,也可以是xml,相关类: ContentResolver(内容解析器), ContentObserver(数据 观察者)
5) 网络存储 天气数据的xml,json格式等等,通过HttpUrlConnection,HttpClient,或者SOAP协议获取数据

什么是ANR 如何避免它

ANR:Application Not Responding(应用程序无响应).当出现下列情况时,Android就会显示ANR对话框了: 对输入事件(如按键、触摸屏事件)的响应超过5秒 意向接受器(intentReceiver)超过10秒钟仍未执行完毕Android应用程序完全运行在一个独立的线程中(例如main)。这就意味着,任何在主线程中运行的,需要消耗大量时间的操作都会引发ANR。
解决方案有两种:
1. AsyncTask异步任务中,doInBackground()和onPostExecute(Result)两个方法非常重要
doInBackground() 这个方法运行在后台线程中,主要负责执行那些很耗时的操作,如移动护理系统中的网络连接、解析XML等操作。该方法必须重载。
onPostExecute(Result) 这个方法也运行于UI线程,在doInBackground(Params…)方法执行后调用,该方法用于处理后台任务执行后返回的结果。
2. 子thread + handler

Handler的运行机制

一个Handler允许你发送和处理Message和Runable对象,每个线程都有自己的Looper,每个Looper中封装着MessageQueue。Looper负责不断的从自己的消息队列里取出队头的任务或消息执行。每个handler也和线程关联,Handler负责把Message和Runable对象传递给MessageQueue(用到post ,sendMessage等方法),而且在这些对象离开MessageQueue时,Handler负责执行他们(用到handleMessage方法)。
其中Message类就是定义了一个信息,这个信息中包含一个描述符和任意的数据对象,这个信息被用来传递给Handler.Message对象提供额外的两个int域和一个Object域。

Listview优化策略

1)对convetView进行判空,是当convertView不为空的时候直接重新使用convertView从而减少了很多不必要的View的创建
2)定义一个ViewHolder,将convetView的tag设置为ViewHolder,不为空时重新使用即可
3)当ListView加载数据量较大时可以采用分页加载和图片异步加载

ListView分页加载实现思路

实现OnScrollListener 接口重写onScrollStateChanged 和onScroll方法,使用onscroll方法实现”滑动“后处理检查是否还有新的记录,如果有,调用 addFooterView,添加记录到adapter, adapter调用 notifyDataSetChanged 更新数据;如果没有记录了,把自定义的mFooterView去掉。使用onScrollStateChanged可以检测是否滚到最后一行且停止滚动然后执行加载

ListView图片异步加载实现思路

1.先从内存缓存中获取图片显示(内存缓冲)
2.获取不到的话从SD卡里获取(SD卡缓冲,,从SD卡获取图片是放在子线程里执行的,否则快速滑屏的话会不够流畅)
3.都获取不到的话从网络下载图片并保存到SD卡同时加入内存并显示(视情况看是否要显示)

Intent的原理,作用,可以传递哪些类型的参数

Intent是连接Activity, Service, BroadcastReceiver, ContentProvider四大组件的信使,,可以传递八种基本数据类型以及string, Bundle类型,以及实现了Serializable或者Parcelable的类型。
Intent可以划分成显式意图和隐式意图。
显式意图:调用Intent.setComponent()或Intent.setClass()方法明确指定了组件名的Intent为显式意图,显式意图明确指定了Intent应该传递给哪个组件。
隐式意图:没有明确指定组件名的Intent为隐式意图。 Android系统会根据隐式意图中设置的动作(action)、类别(category)、数据(URI和数据类型)找到最合适的组件来处理这个意图。

如何实现屏幕分辨率的自适应

最好可以通过权重(layout_weight)的方式来分配每个组件的大小,也可以通过具体的像素(dip)来确定大小。
尽量使用Relativelayout 。
已知应用支持平台设备的分辨率,可以提供多个layout_320*480 ...
drawable-hdpi,drawable-mdpi,drawable-ldpi分别代表分辨率为480*800,360*480,240*360, 放置图片大小相差1.5倍
最后还需要在AndroidManifest.xml里添加下面一段,没有这一段自适应就不能实现:
android:largeScreens="true"
android:normalScreens="true"
android:anyDensity = "true"/>
在标签和 标签之间添加上面那段代码。即可。
备注:三者的解析度不一样,就像你把电脑的分辨率调低,图片会变大一样,反之分辨率高,图片缩小
还可以通过.9.png实现图片的自适应

Android程序入口如何判断

action节点中的android.intent.action.MAIN表明它所在的Activity是整个应用程序的入口点

Android哪几种方式访问网络

HttpURLConnection
HttpClient方式(HttpGet和HttpPost类)
Volley

移动互联数据交互格式有哪些及其区别

移动互联数据交互格式有XML和JSON
1.JSON和XML的数据可读性基本相同
2.JSON和XML同样拥有丰富的解析手段
3.JSON相对于XML来讲,数据的体积小
4.JSON与JavaScript的交互更加方便
5.JSON对数据的描述性比XML较差
6.JSON的速度要远远快于XML

XML解析有哪几种

基本的解析方式有三种: DOM,SAX,Pull
1.dom解析解析器读入整个文档,然后构建一个驻留内存的树结构,然后代码就可以使用 DOM 接口来操作这个树结构的优点是对文档增删改查比较方便,缺点占用内存比较大。
2.sax解析基于事件驱动型,优点占用内存少,解析速度快,缺点是只适合做文档的读取,不适合做文档的增删改查。
3.pull解析同样基于事件驱动型,android 官方API提供,可随时终止

GC内存泄露在什么情况下回出现?怎么解决?

(一) 查询数据库没有关闭游标
(二) 构造Adapter时,没有使用缓存的 convertView
(三) Bitmap对象不在使用时调用recycle()释放内存
(四) 不用的对象没有及时释放对象的引用

Android内存的优化

Android内存泄露容易导致内存溢出,又称为OOM。
Android内存优化策略:
1)在循环内尽量不要使用局部变量
2)不用的对象即时释放,即指向NULL
3)数据库的cursor即时关闭。
4)构造adapter时使用缓存contentview
5)调用registerReceiver()后在对应的生命周期方法中调用unregisterReceiver()
6)即时关闭InputStream/OutputStream。
7)android系统给图片分配的内存只有8M, 图片尽量使用软引用, 较大图片可通过BitmapFactory缩放后再使用,并及时recycle
8)尽量避免static成员变量引用资源耗费过多的实例。

加载大图片的时候如何防止内存溢出

Android系统给图片分配的内存只有8M,当加载大量图片时往往会出现OOM。
Android加载大量图片内存溢出解决方案:
1)尽量不要使用setImageBitmap或setImageResource或BitmapFactory.decodeResource来设置一张大图,因为这些函数在完成decode后,最终都是通过java层的createBitmap来完成的,需要消耗更多内存,可以通过BitmapFactory.decodeStream方法,创建出一个bitmap,再将其设为ImageView的 source
2)使用BitmapFactory.Options对图片进行压缩
InputStream is = this.getResources().openRawResource(R.drawable.pic1);
BitmapFactory.Options options=new BitmapFactory.Options();
options.inJustDecodeBounds = false;
options.inSampleSize = 10; //width,hight设为原来的十分一
Bitmap btp =BitmapFactory.decodeStream(is,null,options);
3)运用Java软引用,进行图片缓存,将需要经常加载的图片放进缓存里,避免反复加载
及时销毁不再使用的Bitmap对象
if(!bmp.isRecycle() ){
bmp.recycle() //回收图片所占的内存
system.gc() //提醒系统及时回收
}

Android缓存机制

客户端缓存机制是android应用开发中非常重要的一项工作,使用缓存机制不仅仅可以为用户节省3G流量,同时在用户体验方面也是非常好的选择,比如有些新闻客户端支持离线模式,也是通过缓存机制实现的.缓存机制分为两部分,一部分是文字缓存,另一部分是多媒体文件缓存.
文字缓存有两种实现:
1)可以将与服务器交互得到的json数据或者xml数据存入sd卡中,并在数据库添加该数据的记录.添加数据库记录时,提供两个关键字段,一个是请求的URL,另一个则是本地保存后的文件地址,每次加载数据之前都会根据URL在数据库中检索
2)将JSON数据解析后装入List对象中,然后遍历List,将数据统统写入相应的数据库表结构中,以后每次向服务器发起请求之前可以先在数据库中检索,如果有直接返回.
多媒体文件缓存:主要指图片缓存
图片的缓存可以根据当前日期,时间为名字缓存到SD卡中的指定图片缓存目录,同时数据库中做相应记录,记录办法可以采用两个关键字段控制,一个字段是该图片的URL地址,另一个字段是该图片的本机地址.取图片时根据URL在数据中检索,如果没有则连接服务器下载,下载之后再服务器中作出相应记录
缓存文件删除策略:
1. 每一个模块在每次客户端自动或者用户手动更新的时候删除相应模块的缓存文件,并重新下载新的缓存文件.
2. 在设置界面中提供删除缓存的功能,点击后删除本机所有缓存.

如何实现消息推送,有哪些方式,各自优缺点,最常使用哪种?

实现消息推送的方式有五种,分别是轮询,SMS,C2DM,MQTT,XMPP最常使用的是XMPP, 我们做项目时采用的是XMPP协议
1.XMPP协议,它是一种基于XML的传递协议,具有很强的灵活性和可扩展性。它的特点是将复杂性从客户端转移到了服务器端。GTalk、QQ、IM等都用这个协议。
2.轮询:客户端定时去服务端取或者保持一个长Socket,从本质讲这个不叫推送, 而是去服务端拽数据。但是实现简单,主要缺点:耗电,浪费用户流量等
3.Google的C2DM,具体不细说,缺点,服务器在国外,不是很稳定。
4.通过短信方式, 但是很难找到免费短信平台
5. MQTT协议, IBM提供的一种推送服务,不太灵活

MVC在Android中的应用

Android中界面部分也采用了当前比较流行的MVC框架,在Android中:
1) 视图层(View):一般采用XML文件进行界面的描述,使用的时候可以非常方便的引入。也可以使用JavaScript+HTML等的方式作为View层,通过WebView组件加载,同时可以实现Java和JavaScript之间的通信。
2) 控制层(Controller):这句话也就暗含了不要在Acitivity中写代码,要通过Activity交割Model业务逻辑层处理,这样做的另外一个原因是Android中的Acitivity的响应时间是5s,如果耗时的操作放在这里,Android的控制层的重任通常落在了众多的Acitvity的肩上,程序就很容易被回收掉。
3) 模型层(Model):对数据库的操作、对网络等的操作都应该在Model里面处理,当然对业务计算等操作也是必须放在的该层的。
在Android SDK中的数据绑定,也都是采用了与MVC框架类似的方法来显示数据。在控制层上将数据按照视图模型的要求(也就是Android SDK中的Adapter)封装就可以直接在视图模型上显示了,从而实现了数据绑定。比如显示Cursor中所有数据的ListActivity,其视图层就是一个ListView,将数据封装为ListAdapter,并传递给ListView,数据就在ListView中显示。

Android自定义组件实现思路

Android自定义组件有三种实现思路:
1) 继承某个现有组件,在其基础上添加额外功能,如继承Gallery实现CoverFlow效果
2) 继承某个Layout,实现复合组件自定义,如TextView和EditText组合实现登录注册组件
3) 继承View,实现onDraw()方法,实现自己绘制组件,如翻页效果组件

版本更新的实现思路

在服务器相应URL上有版本文件, 客户端同时存储该应用当前版本号 (SharedPreferences/Sqlite), 每次打开应用,去检测服务器版本号与本地版本号是否一致,如果不一 致,则自定义对话框提示是否下载更新

播放视频有哪些实现方式

1.使用系统自带的播放器来播放,指定Action为ACTION_VIEW,Data为Uri,Type为其MIME类型。
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setDataAndType(uri, "video/mp4");
startActivity(intent);
2. 使用VideoView组件来播放, 可以结合MediaController来实现播控, 只是不能随意更改视频的大小及位置。
3. 使用MediaPlayer和SurfaceView来实现,这种方式很灵活,可以自定义视频播放的大小和位置。

NDK开发流程

NDK应用的开发流程(在应用中定义本地接口(native), 编译成.h头文件,交由C程序员实现,将.c实现通过NDK编译成.so动态链接库,导入项目中libs/armeabi,代码中调用该本地接口)
应用场景: 音频,视频解码,拍摄车牌号,识别车牌号

如何实现一键退出

定义一个类继承Application,定义一个集合存放所有的activity,
定义一个添加的方法,再写一个退出的方法,使用for循环全部调用finish方法,然
后在每个Activity的onCreate方法中调用自定义类里的添加方法,然后在需要使用一键退出的地方调用类中的退出方法即可。

Android客户端如何实现自动登录

通过SharedPreferences存储用户名,密码,当存储不为空时实现自动登录功能

相信已经有一些同学已经对怎么开发Android应用有了一些感觉了,在一些网友发给我的工程中有很多也都加入了自己个性化的东西,这样很好。

现在我们回过头来看看我们都学到了哪些知识。

 

第一天

万事开头难,我们在这一天里搭建了基础的开发环境,并且做出了第一个页面,俗称“Hello,world”。

 

第二天

我们初步了解了布局文件,并且使用了第三方库-xUtils进行了http访问,调用了百度天气API并且把天气信息以文本的形式展现出来了。

 

第三天

我们较为深入的学习了常见的各种布局,并且重点学习了ListView 的使用。

 

第四天

天气信息终于能够以列表的形式展示了,并且还有天气小图标哦。这里有一个重要的类:BaseAdapter,一定要熟练掌握这个类,会经常用到。

 

第五天

进行了理论知识的补充,对Android的体系架构、项目结构有了初步认识。

 

第六天

有突破的一天,我们学习了百度定位的使用,并且学习了Preference这一经常会用到的本地数据存储方式。

 

第七天

理论知识进一步深入,对于Activity的生命周期有了更加深刻的理解。

 

第八天

这一天的内容很多很多,并且都很重要。主要是Activity间传值、Application的使用、本地数据库的使用、文本框事件监听,并根据我们对Activity生命周期的理解重构了代码。

 

第九天

主要学习了Fragment的使用,以及Fragment和ViewPager的搭配使用,可以做出左右滑动的界面哦。

 

第十天

这一天的主要工作就是打包、发布我们的天气预报APP了。

 

经过这十天的学习,相信很多同学都可以初步开发出一些简单的APP了,如果大家还有什么疑问、建议,都可以加入我们的Android学习群:44133900,我们一起来交流。

此系列文章系本人原创,如需转载,请注明出处 www.liuzhibang.cn

接着昨天的任务,我们今天实现左右滑动可以切换城市的功能。

这里就需要引入新的控件了,Android给我们提供了ViewPager,我们就使用这个,同时,显示天气的界面我们也不再使用Activity,而改为Fragment。

Fragment

Fragment可以认为是可复用的UI组件,有自己的布局和完整的生命周期,可以处理本身的事件,但是必须依存于Activity,不能脱离Activity而存在。

08162501-0d1530c0e072468b8b0a68c1c8913bce

 

可以看出来,Fragment的生命周期跟Activity非常相似,并且会随着Activity的销毁而销毁。

 

下面,我们来战。

首先,新建一个Fragment的子类,取名为WeatherFragment。

public class WeatherFragment extends Fragment
{
    @Override
    public void onCreate( Bundle savedInstanceState )
    {
        super.onCreate( savedInstanceState );
    }

    @Override
    public View onCreateView( LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState )
    {
        return super.onCreateView( inflater, container, savedInstanceState );
    }
}

这是用来显示天气的界面,而我们之前是直接在Activity中显示的,需要把这部分代码给移植到Fragment中。

这是个麻烦的过程,不过不要紧,慢慢来。

新建一个Layout,取名为frag_weather.xml,然后把activity_main.xml中的代码给复制过来,

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"  >

    <ListView
        android:id="@+id/weather_list"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true" >
    </ListView>

</RelativeLayout>

 

我们让WeatherFragment使用新的Layout,再把MainActivity中关于天气的代码移植到WeatherFragment中,

public class WeatherFragment extends Fragment
{
    @ViewInject( R.id.weather_list )
    private ListView lstWeather;

    private WeatherAdapter adapter;
    private BaiduData data;

    private List<WeatherDataBean> datas;
    private String city;

    public void setCity( String city )
    {
        this.city = city;
    }

    @Override
    public void onCreate( Bundle savedInstanceState )
    {
        super.onCreate( savedInstanceState );

        datas = new ArrayList<WeatherDataBean>();
        adapter = new WeatherAdapter( getActivity(), datas );
    }

    @Override
    public View onCreateView( LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState )
    {
        View view = inflater.inflate( R.layout.frag_weather, null );
        ViewUtils.inject( this, view );

        lstWeather.setAdapter( adapter );

        getWeather();

        return view;
    }

    private void getWeather()
    {
        HttpUtils http = new HttpUtils();

        RequestParams params = new RequestParams();
        params.addQueryStringParameter( "location", city );
        params.addQueryStringParameter( "output", "json" );
        params.addQueryStringParameter( "ak", "YknGmxIoPugT7YrNrG955YLS" );

        http.send( HttpMethod.GET, "http://api.map.baidu.com/telematics/v3/weather", params, new RequestCallBack<String>()
        {
            @Override
            public void onSuccess( ResponseInfo<String> responseInfo )
            {
                String weather = responseInfo.result;

                Gson gson = new Gson();
                data = gson.fromJson( weather, BaiduData.class );

                datas.clear();
                datas.addAll( data.getResults().get( 0 ).getWeather_data() );
                adapter.notifyDataSetChanged();

                Log.v( "onSuccess", data.toString() );
            }

            @Override
            public void onFailure( HttpException arg0, String arg1 )
            {
                Log.v( "onFailure", arg1 );
            }
        } );
    }
}

 

然后,修改主页面activity_main.xml为:

<?xml version="1.0"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <android.support.v4.view.ViewPager
        android:id="@+id/viewPager"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content" />

    <LinearLayout
        android:id="@+id/viewGroup"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:layout_marginBottom="30dp"
        android:gravity="center_horizontal"
        android:orientation="horizontal" >
    </LinearLayout>

</RelativeLayout>

这里我们引入了ViewPager,并且还有一个LinearLayout,其中ViewPager我们用来显示天气,Linearlayout用来作为指示器,表示我们当前所选城市的次序。

 

之后,修改我们主页面的代码,主界面现在的作用主要是两个:

1. 初次启动的时候,获取所在地城市

2. 处理切换Fragment的逻辑

3. 处理页面跳转/返回的逻辑

public class MainActivity extends FragmentActivity
{
    @ViewInject( R.id.viewPager )
    private ViewPager pager;

    @ViewInject( R.id.viewGroup )
    private LinearLayout layout;

    private MyAdapter mAdapter;
    private List<SelectCityBean> citys;

    private LocationClient mLocationClient;
    private BDLocationListener myListener;

    private List<ImageView> imageViews;

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

        Log.v( "WeatherAPP", "onCreate" );

        ViewUtils.inject( this );

        imageViews = new ArrayList<ImageView>();

        citys = readCity();
        mAdapter = new MyAdapter( getSupportFragmentManager() );
        pager.setAdapter( mAdapter );
        pager.setOnPageChangeListener( new OnPageChangeListener()
        {
            @Override
            public void onPageSelected( int arg0 )
            {
                setTitle( citys.get( arg0 ).getCityName() + "天气" );
                setImageBackground( arg0 );
            }

            @Override
            public void onPageScrolled( int arg0, float arg1, int arg2 )
            {
            }

            @Override
            public void onPageScrollStateChanged( int arg0 )
            {
            }
        } );

        if( citys == null || citys.size() == 0 )
        {
            citys = new ArrayList<SelectCityBean>();
            initLocationClient();
            mLocationClient.start();
        }

        showIndicator( 0 );
    }

    private void showIndicator( int position )
    {
        layout.removeAllViews();
        imageViews = new ArrayList<ImageView>();

        pager.setCurrentItem( position );

        for( int i = 0; i < citys.size(); i++ )
        {
            ImageView imageView = new ImageView( this );
            LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams( 20, 20 );
            lp.leftMargin = 5;
            imageView.setLayoutParams( lp );
            imageViews.add( imageView );
            if( i == position )
            {
                setTitle( citys.get( position ).getCityName() + "天气" );
                imageView.setBackgroundResource( R.drawable.page_indicator_focused );
            }
            else
            {
                imageView.setBackgroundResource( R.drawable.page_indicator_unfocused );
            }

            layout.addView( imageView );
        }
    }

    private void setImageBackground( int selectItems )
    {
        for( int i = 0; i < imageViews.size(); i++ )
        {
            if( i == selectItems )
            {
                imageViews.get( i ).setBackgroundResource( R.drawable.page_indicator_focused );
            }
            else
            {
                imageViews.get( i ).setBackgroundResource( R.drawable.page_indicator_unfocused );
            }
        }
    }

    @Override
    public boolean onCreateOptionsMenu( Menu menu )
    {
        super.onCreateOptionsMenu( menu );
        menu.add( Menu.NONE, Menu.FIRST + 1, 0, "添加城市" ).setShowAsAction( MenuItem.SHOW_AS_ACTION_ALWAYS );
        return true;
    }

    @Override
    public boolean onOptionsItemSelected( MenuItem item )
    {
        if( item.getItemId() == Menu.FIRST + 1 )
        {
            Intent intent = new Intent( getApplicationContext(), ChooseCityActivity.class );
            intent.putExtra( "key", "value" );
            startActivityForResult( intent, 99 );
        }

        return super.onOptionsItemSelected( item );
    }

    @Override
    protected void onActivityResult( int requestCode, int resultCode, Intent data )
    {
        super.onActivityResult( requestCode, resultCode, data );

        if( resultCode == RESULT_OK )
        {
            String city = data.getStringExtra( "selectedCity" );
            addCity( city );
        }
    }

    private void initLocationClient()
    {
        mLocationClient = new LocationClient( getApplicationContext() ); // 声明LocationClient类
        myListener = new MyLocationListener();
        LocationClientOption option = new LocationClientOption();
        option.setLocationMode( LocationMode.Hight_Accuracy );
        option.setIsNeedAddress( true );
        mLocationClient.setLocOption( option );
        mLocationClient.registerLocationListener( myListener );
    }

    @Override
    protected void onStop()
    {
        Log.v( "WeatherAPP", "onStop" );
        super.onStop();
        if( mLocationClient != null ) mLocationClient.stop();
    }

    @Override
    protected void onPause()
    {
        Log.v( "WeatherAPP", "onPause" );
        super.onPause();
    }

    @Override
    protected void onRestart()
    {
        Log.v( "WeatherAPP", "onRestart" );
        super.onRestart();
    }

    @Override
    protected void onResume()
    {
        Log.v( "WeatherAPP", "onResume" );
        super.onResume();
    }

    @Override
    protected void onStart()
    {
        Log.v( "WeatherAPP", "onStart" );
        super.onStart();
    }

    @Override
    protected void onDestroy()
    {
        Log.v( "WeatherAPP", "onDestroy" );
        super.onDestroy();
    }

    public class MyLocationListener implements BDLocationListener
    {
        @Override
        public void onReceiveLocation( BDLocation location )
        {
            String city = location.getCity();
            addCity( city );
        }
    }

    private void addCity( String city )
    {
        SelectCityBean cityBean = new SelectCityBean();
        cityBean.setCityName( city );
        saveCity( cityBean );

        if( citys == null ) citys = new ArrayList<SelectCityBean>();
        citys.add( cityBean );
        mAdapter.notifyDataSetChanged();
        showIndicator( citys.size() - 1 );
    }

    private void saveCity( SelectCityBean city )
    {
        DbUtils dbUtils = WeatherApplication.getInstance().getDbUtil();
        try
        {
            dbUtils.save( city );
        }
        catch( DbException e )
        {
        }
    }

    private List<SelectCityBean> readCity()
    {
        DbUtils dbUtils = WeatherApplication.getInstance().getDbUtil();
        try
        {
            return dbUtils.findAll( SelectCityBean.class );
        }
        catch( DbException e )
        {
            return null;
        }
    }

    public class MyAdapter extends FragmentStatePagerAdapter
    {
        public MyAdapter( FragmentManager fm )
        {
            super( fm );
        }

        @Override
        public Fragment getItem( int arg0 )
        {
            WeatherFragment fragment = new WeatherFragment();
            fragment.setCity( citys.get( arg0 ).getCityName() );
            return fragment;
        }

        @Override
        public int getItemPosition( Object object )
        {
            return POSITION_NONE;
        }

        @Override
        public int getCount()
        {
            if( citys == null ) return 0;
            return citys.size();
        }
    }
}

 

基本上面目全非了,跟之前的代码完全不一样了,这里面的主要变动为:

1. saveCity、readCity不再从Preference中获取数据了,而改为从数据库获取

2. 增加了MyAdapter以及相关的ViewPager的逻辑

 

这里还用到了一个新的SelectCityBean以及两个图片资源,

public class SelectCityBean
{
    private int id;
    private String cityName;

    public int getId()
    {
        return id;
    }

    public void setId( int id )
    {
        this.id = id;
    }

    public String getCityName()
    {
        return cityName;
    }

    public void setCityName( String cityName )
    {
        this.cityName = cityName;
    }
}

 

两个图片资源分别代表了当前城市以及其他城市,

page_indicator_focusedpage_indicator_unfocused

 

完成之后,运行来看看,我这边的效果是这样的:

device-2015-01-27-084239

 

 

你可以试着添加城市看看,是不是这样的效果。

 

今天的内容比较少,代码比较多,大家多多练习一下。

 

附件是本次的工程文件,点击下载 http://pan.baidu.com/s/1sj2V5fB 。

此系列文章系本人原创,如需转载,请注明出处 www.liuzhibang.cn

 

昨天郑州雨夹雪,还有冰雹,结果小区就断电了,真是悲剧。第八天的学习就挪到今天了。

经过前几天的学习,我们了解了一些Android的基础知识,并且做出了一个也算实用的天气预报APP,对Android也算得上是入门了,那么今天我们继续改进我们的APP。

这个APP现在只能查看所在城市的天气,那么万一妹子不跟我们一个城市,我们就不能关注到妹子所在城市的天气了,那还怎么嘘寒问暖呢,这个问题是一定要解决的。

 

如何解决?

那就是需要在一个界面上可以选择城市了,这就用到了数据库了。

我整理了一份所有城市的名单:

北京市,天津市,上海市,重庆市,邯郸市,石家庄市,保定市,张家口市,承德市,唐山市,廊坊市,沧州市,衡水市,邢台市,秦皇岛市,朔州市,忻州市,太原市,大同市,阳泉市,晋中市,长治市,晋城市,临汾市,吕梁市,运城市,沈阳市,铁岭市,大连市,鞍山市,抚顺市,本溪市,丹东市,锦州市,营口市,阜新市,辽阳市,朝阳市,盘锦市,葫芦岛市,长春市,吉林市,延边朝鲜族自治州,四平市,通化市,白城市,辽源市,松原市,白山市,哈尔滨市,齐齐哈尔市,鸡西市,牡丹江市,七台河市,佳木斯市,鹤岗市,双鸭山市,绥化市,黑河市,大兴安岭地区,伊春市,大庆市,南京市,无锡市,镇江市,苏州市,南通市,扬州市,盐城市,徐州市,淮安市,连云港市,常州市,泰州市,宿迁市,舟山市,衢州市,杭州市,湖州市,嘉兴市,宁波市,绍兴市,温州市,丽水市,金华市,台州市,合肥市,芜湖市,蚌埠市,淮南市,马鞍山市,淮北市,铜陵市,安庆市,黄山市,滁州市,阜阳市,宿州市,巢湖市,六安市,亳州市,池州市,宣城市,福州市,厦门市,宁德市,莆田市,泉州市,漳州市,龙岩市,三明市,南平市,鹰潭市,新余市,南昌市,九江市,上饶市,抚州市,宜春市,吉安市,赣州市,景德镇市,萍乡市,菏泽市,济南市,青岛市,淄博市,德州市,烟台市,潍坊市,济宁市,泰安市,临沂市,滨州市,东营市,威海市,枣庄市,日照市,莱芜市,聊城市,商丘市,郑州市,安阳市,新乡市,许昌市,平顶山市,信阳市,南阳市,开封市,洛阳市,济源市,焦作市,鹤壁市,濮阳市,周口市,漯河市,驻马店市,三门峡市,武汉市,襄樊市,鄂州市,孝感市,黄冈市,黄石市,咸宁市,荆州市,宜昌市,恩施土家族苗族自治州,神农架林区,十堰市,随州市,荆门市,仙桃市,天门市,潜江市,岳阳市,长沙市,湘潭市,株洲市,衡阳市,郴州市,常德市,益阳市,娄底市,邵阳市,湘西土家族苗族自治州,张家界市,怀化市,永州市,广州市,汕尾市,阳江市,揭阳市,茂名市,惠州市,江门市,韶关市,梅州市,汕头市,深圳市,珠海市,佛山市,肇庆市,湛江市,中山市,河源市,清远市,云浮市,潮州市,东莞市,兰州市,金昌市,白银市,天水市,嘉峪关市,武威市,张掖市,平凉市,酒泉市,庆阳市,定西市,陇南市,临夏回族自治州,甘南藏族自治州,成都市,攀枝花市,自贡市,绵阳市,南充市,达州市,遂宁市,广安市,巴中市,泸州市,宜宾市,资阳市,内江市,乐山市,眉山市,凉山彝族自治州,雅安市,甘孜藏族自治州,阿坝藏族羌族自治州,德阳市,广元市,贵阳市,遵义市,安顺市,黔南布依族苗族自治州,黔东南苗族侗族自治州,铜仁地区,毕节地区,六盘水市,黔西南布依族苗族自治州,海口市,三亚市,五指山市,琼海市,儋州市,文昌市,万宁市,东方市,澄迈县,定安县,屯昌县,临高县,白沙黎族自治县,昌江黎族自治县,乐东黎族自治县,陵水黎族自治县,保亭黎族苗族自治县,琼中黎族苗族自治县,西双版纳傣族自治州,德宏傣族景颇族自治州,昭通市,昆明市,大理白族自治州,红河哈尼族彝族自治州,曲靖市,保山市,文山壮族苗族自治州,玉溪市,楚雄彝族自治州,普洱市,临沧市,怒江傈傈族自治州,迪庆藏族自治州,丽江市,海北藏族自治州,西宁市,海东地区,黄南藏族自治州,海南藏族自治州,果洛藏族自治州,玉树藏族自治州,海西蒙古族藏族自治州,西安市,咸阳市,延安市,榆林市,渭南市,商洛市,安康市,汉中市,宝鸡市,铜川市,防城港市,南宁市,崇左市,来宾市,柳州市,桂林市,梧州市,贺州市,贵港市,玉林市,百色市,钦州市,河池市,北海市,拉萨市,日喀则地区,山南地区,林芝地区,昌都地区,那曲地区,阿里地区,银川市,石嘴山市,吴忠市,固原市,中卫市,塔城地区,哈密地区,和田地区,阿勒泰地区,克孜勒苏柯尔克孜自治州,博尔塔拉蒙古自治州,克拉玛依市,乌鲁木齐市,石河子市,昌吉回族自治州,五家渠市,吐鲁番地区,巴音郭楞蒙古自治州,阿克苏地区,阿拉尔市,喀什地区,图木舒克市,伊犁哈萨克自治州,呼伦贝尔市,呼和浩特市,包头市,乌海市,乌兰察布市,通辽市,赤峰市,鄂尔多斯市,巴彦淖尔市,锡林郭勒盟,兴安盟,阿拉善盟,台北市,高雄市,基隆市,台中市,台南市,新竹市,嘉义市,澳门特别行政区,香港特别行政区

 

这里基本囊括了国内大部分城市,我们做一个界面从这里选择就好了。

开工。

 

新建一个Activity,取名为ChooseCityActivity,并且修改AndroidManifest.xml,在application节点添加一个activity,如下:

<activity android:name="com.demo.weather.ChooseCityActivity"></activity>

 

这样就添加了一个新的Activity到APP中,不过现在还是空的,没有内容,不着急,我们过会儿会添加进去。

 

然后修改MainActivity,添加两个方法:

    @Override
    public boolean onCreateOptionsMenu( Menu menu )
    {
        super.onCreateOptionsMenu( menu );
        menu.add( Menu.NONE, Menu.FIRST + 1, 0, "添加城市" ).setShowAsAction( MenuItem.SHOW_AS_ACTION_ALWAYS );
        return true;
    }

    @Override
    public boolean onOptionsItemSelected( MenuItem item )
    {
        if( item.getItemId() == Menu.FIRST + 1 )
        {
            startActivityForResult( new Intent( getApplicationContext(), ChooseCityActivity.class ), 99 );
        }

        return super.onOptionsItemSelected( item );
    }

 

第一个方法的作用是在右上角添加了一个名为“添加城市”的按钮,第二个方法的作用就是点击了“添加城市”的按钮后,会跳转到我们新建的那个Activity。

 

ActionBar

我们这里用到了ActionBar,一个完整的ActionBar是这样子的:

2224215266067739940

一共分为四部分,

1. App Icon,也可替换为任意的图标

2. View Controller,这部分为下拉菜单或者Tab选项卡,或者是App Title

3. Action Item,这部分就是我们上面那两个方法进行设置的,每一个Action Item都会包含文字、图标

4. Action Overflow,如果第三部分的Action Item比较多显示不全的时候,就会在这里以列表的形式展示

每一个Action Item都可以通过调用setShowAsAction来设置它的展示方式,在前面我们添加了一个Action Item,并且设置为SHOW_AS_ACTION_ALWAYS,这就要求这个Item是必须显示在第三部分的。

 

了解了一些ActionBar的基础知识后,我们继续之前的学习。

现在的界面应该是这个样子的:

device-2015-01-25-143330

 

点击“添加城市”后,就跳转到了一个空白页面。

 

跳转+传值

Android中页面跳转提供了两种方法,startActivityForResult和startActivity,这两个方法区别在于能否将结果回传。

 

传值

假如MainActivity需要向ChooseCityActivity传值,可以这么做:

            Intent intent = new Intent( getApplicationContext(), ChooseCityActivity.class );
            intent.putExtra( "key", "value" );
            startActivityForResult( intent, 99 );

并且在ChooseCityActivity的onCreate方法中进行接收:

    protected void onCreate( Bundle savedInstanceState )
    {
        super.onCreate( savedInstanceState );

        String value = getIntent().getStringExtra( "key" );
        Log.v( "ChooseCityActivity", value );
    }

 

回传

假如这个时候ChooseCityActivity需要把一些数据回传,可以这么做:

        Intent intent = new Intent();
        intent.putExtra( "key2", "value2" );
        setResult( RESULT_OK, intent );
        super.finish();

并且在MainActivity添加onActivityResult方法:

    protected void onActivityResult( int requestCode, int resultCode, Intent data )
    {
        super.onActivityResult( requestCode, resultCode, data );

        Log.v( "onActivityResult", data.getStringExtra( "key2" ) );
    }

 

了解了这些内容,Activity间的传值就没有问题了,可以传很多类型的数据,包括基本类型以及实现了Serializable或者Parcelable接口的类型,Serializable是Java标准的序列化接口,Parcelable是Google定义的效率更高的序列化接口,如果是复杂类型,推荐大家使用Parcelable接口。

 

希望大家掌握这些知识点,这些内容会在实际的应用中频繁使用。

我们继续之前的学习,这次的目标是在新的界面实现选择城市并且传回MainActivity,为了做到这一点,这个界面需要有一个可以输入关键字的文本框已经一个城市列表,知道要做什么了,就动起手来吧。

还记得怎么新建一个Layout吗?如果忘记了,请看这里:http://liuzhibang.cn/?p=380

这次我们新建的Layout可以起名为:activity_choose_city,并且我们这次尝试使用LinearLayout,

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <EditText
        android:id="@+id/choose_key"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:ems="10" >
    </EditText>

    <ListView
        android:id="@+id/choose_list"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" >
    </ListView>

</LinearLayout>

 

这个界面有一个文本框和一个列表,并且是垂直排列,占满了整个屏幕。

界面已经好了,接下来我们需要把数据以某种方式存储起来,并且在文本框输入了关键字后进行筛选,把筛选的城市显示到列表中。

 

怎样把那么些个城市数据存储起来?什么时候进行这个操作呢?

 

Application

为什么我们的手机应用都叫APP呢?

那是因为我们所做出来的每一个应用都是一个Android Application,而APP就是Application的缩写,可见Application的重要性了。

实际上,Application是Android框架的系统组件,当应用启动的时候就会创建一个且只有一个Application对象,用来存储APP的一些信息,所有说Application是一个单例模式。既然是单例对象,那么我们就可以在这里保存一些全局的数据,例如我们的城市数据;或者进行一些必要的初始化操作,比如把我们的城市数据存储起来。

要做到这些,只需要继承Application这个类,实现我们自己的Application就可以了。

新建一个类WeatherApplication,让它继承Application,并且实现它的onCreate方法:

public class WeatherApplication extends Application
{
    @Override
    public void onCreate()
    {
        super.onCreate();
    }
}

这个onCreate就是实际意义的整个APP的入口,每次启动都会执行这个方法,我们在这里把城市数据存储到数据库中。

 

然后修改AndroidManifest.xml,在application节点添加:

android:name="com.demo.weather.WeatherApplication"

这就指定了这个应用的Application就是WeatherApplication,然后修改WeatherApplication,进行我们的初始化数据的操作。

public class WeatherApplication extends Application
{
    private String citys = "北京市,天津市,上海市,重庆市,邯郸市,石家庄市,保定市,张家口市,承德市,唐山市,廊坊市,沧州市,衡水市,邢台市,秦皇岛市,朔州市,忻州市,太原市,大同市,阳泉市,晋中市,长治市,晋城市,临汾市,吕梁市,运城市,沈阳市,铁岭市,大连市,鞍山市,抚顺市,本溪市,丹东市,锦州市,营口市,阜新市,辽阳市,朝阳市,盘锦市,葫芦岛市,长春市,吉林市,延边朝鲜族自治州,四平市,通化市,白城市,辽源市,松原市,白山市,哈尔滨市,齐齐哈尔市,鸡西市,牡丹江市,七台河市,佳木斯市,鹤岗市,双鸭山市,绥化市,黑河市,大兴安岭地区,伊春市,大庆市,南京市,无锡市,镇江市,苏州市,南通市,扬州市,盐城市,徐州市,淮安市,连云港市,常州市,泰州市,宿迁市,舟山市,衢州市,杭州市,湖州市,嘉兴市,宁波市,绍兴市,温州市,丽水市,金华市,台州市,合肥市,芜湖市,蚌埠市,淮南市,马鞍山市,淮北市,铜陵市,安庆市,黄山市,滁州市,阜阳市,宿州市,巢湖市,六安市,亳州市,池州市,宣城市,福州市,厦门市,宁德市,莆田市,泉州市,漳州市,龙岩市,三明市,南平市,鹰潭市,新余市,南昌市,九江市,上饶市,抚州市,宜春市,吉安市,赣州市,景德镇市,萍乡市,菏泽市,济南市,青岛市,淄博市,德州市,烟台市,潍坊市,济宁市,泰安市,临沂市,滨州市,东营市,威海市,枣庄市,日照市,莱芜市,聊城市,商丘市,郑州市,安阳市,新乡市,许昌市,平顶山市,信阳市,南阳市,开封市,洛阳市,济源市,焦作市,鹤壁市,濮阳市,周口市,漯河市,驻马店市,三门峡市,武汉市,襄樊市,鄂州市,孝感市,黄冈市,黄石市,咸宁市,荆州市,宜昌市,恩施土家族苗族自治州,神农架林区,十堰市,随州市,荆门市,仙桃市,天门市,潜江市,岳阳市,长沙市,湘潭市,株洲市,衡阳市,郴州市,常德市,益阳市,娄底市,邵阳市,湘西土家族苗族自治州,张家界市,怀化市,永州市,广州市,汕尾市,阳江市,揭阳市,茂名市,惠州市,江门市,韶关市,梅州市,汕头市,深圳市,珠海市,佛山市,肇庆市,湛江市,中山市,河源市,清远市,云浮市,潮州市,东莞市,兰州市,金昌市,白银市,天水市,嘉峪关市,武威市,张掖市,平凉市,酒泉市,庆阳市,定西市,陇南市,临夏回族自治州,甘南藏族自治州,成都市,攀枝花市,自贡市,绵阳市,南充市,达州市,遂宁市,广安市,巴中市,泸州市,宜宾市,资阳市,内江市,乐山市,眉山市,凉山彝族自治州,雅安市,甘孜藏族自治州,阿坝藏族羌族自治州,德阳市,广元市,贵阳市,遵义市,安顺市,黔南布依族苗族自治州,黔东南苗族侗族自治州,铜仁地区,毕节地区,六盘水市,黔西南布依族苗族自治州,海口市,三亚市,五指山市,琼海市,儋州市,文昌市,万宁市,东方市,澄迈县,定安县,屯昌县,临高县,白沙黎族自治县,昌江黎族自治县,乐东黎族自治县,陵水黎族自治县,保亭黎族苗族自治县,琼中黎族苗族自治县,西双版纳傣族自治州,德宏傣族景颇族自治州,昭通市,昆明市,大理白族自治州,红河哈尼族彝族自治州,曲靖市,保山市,文山壮族苗族自治州,玉溪市,楚雄彝族自治州,普洱市,临沧市,怒江傈傈族自治州,迪庆藏族自治州,丽江市,海北藏族自治州,西宁市,海东地区,黄南藏族自治州,海南藏族自治州,果洛藏族自治州,玉树藏族自治州,海西蒙古族藏族自治州,西安市,咸阳市,延安市,榆林市,渭南市,商洛市,安康市,汉中市,宝鸡市,铜川市,防城港市,南宁市,崇左市,来宾市,柳州市,桂林市,梧州市,贺州市,贵港市,玉林市,百色市,钦州市,河池市,北海市,拉萨市,日喀则地区,山南地区,林芝地区,昌都地区,那曲地区,阿里地区,银川市,石嘴山市,吴忠市,固原市,中卫市,塔城地区,哈密地区,和田地区,阿勒泰地区,克孜勒苏柯尔克孜自治州,博尔塔拉蒙古自治州,克拉玛依市,乌鲁木齐市,石河子市,昌吉回族自治州,五家渠市,吐鲁番地区,巴音郭楞蒙古自治州,阿克苏地区,阿拉尔市,喀什地区,图木舒克市,伊犁哈萨克自治州,呼伦贝尔市,呼和浩特市,包头市,乌海市,乌兰察布市,通辽市,赤峰市,鄂尔多斯市,巴彦淖尔市,锡林郭勒盟,兴安盟,阿拉善盟,台北市,高雄市,基隆市,台中市,台南市,新竹市,嘉义市,澳门特别行政区,香港特别行政区";
    private DbUtils dbUtils;

    private static WeatherApplication instance;

    public static WeatherApplication getInstance()
    {
        return instance;
    }

    @Override
    public void onCreate()
    {
        super.onCreate();
        instance = this;
        dbUtils = DbUtils.create( this );

        if( !readInit() )
        {
            initCity();
        }
    }

    private void initCity()
    {
        boolean isSuccess = true;
        String[] cityArray = citys.split( "," );
        for( String city : cityArray )
        {
            CityBean cityBean = new CityBean();
            cityBean.setCityName( city );
            try
            {
                dbUtils.save( cityBean );
            }
            catch( DbException e )
            {
                isSuccess = false;
            }
        }

        saveInit( isSuccess );
    }

    private void saveInit( boolean isInited )
    {
        SharedPreferences sharedPreferences = getSharedPreferences( "weather", Context.MODE_PRIVATE );
        Editor editor = sharedPreferences.edit();
        editor.putBoolean( "isInited", isInited );
        editor.commit();
    }

    private boolean readInit()
    {
        SharedPreferences sharedPreferences = getSharedPreferences( "weather", Context.MODE_PRIVATE );
        return sharedPreferences.getBoolean( "isInited", false );
    }
}

 

这里用到了CityBean这个类,

public class CityBean
{
    private int id;
    private String cityName;

    public int getId()
    {
        return id;
    }

    public void setId( int id )
    {
        this.id = id;
    }

    public String getCityName()
    {
        return cityName;
    }

    public void setCityName( String cityName )
    {
        this.cityName = cityName;
    }
}

 

这个类是进行数据库操作的类,而我们的数据库操作使用了第三方类库,根据类库的要求,我们这里有一个名为id的字段。

 

做好了这些后,运行程序。

有没有发现特别慢?那是因为我们在启动的时候进行了数据库操作,并且插入了300多条城市数据,这个过程是比较耗时的。

等一切现实正常后,我们退出程序,再重新启动,有没有发现变快了?那是因为我们只在第一次启动的时候进行了数据存储。

这里面用到了一个小技巧:

在数据存储操作后,我们另外在Preference中写入了一个名为isInited的Boolean类型的数据,如果成功,我们就不再进行这个操作了。

 

查看数据库文件

如果你的手机是Root过的,那么你还可以把数据库导出,放到电脑上用工具查看数据是否正确。另外,有一些手机APP,例如Root Explorer也提供了在手机上直接查看数据库的功能,但是毕竟不如在电脑上清晰直观。

每一个APP的数据库、缓存文件都存在/data/data/[package]下面,比如我们的APP,就存在/data/data/com.demo.weather这个目录下面。

需要注意,这个目录在APP被卸载之后会被清空。

device-2015-01-25-143934

 

稍微说明一下这几个目录,

cache:在这里可以存放临时缓存,

databases:就是数据库,我们的数据库文件就在这个目录

files:一般存放一些长时间保存的数据

lib:APP用到库文件

shared_prefs:这个就是SharedPreferences这个类保存的数据

 

跟我们这个APP相关的就只要两个目录:databases和shared_prefs,打开它们:

device-2015-01-25-145619 device-2015-01-25-145633

很清楚,一个数据库文件,另外一个是xml文件。大家可以通过各种办法把这两个文件导出到电脑来查看。

 

接下来的工作就是在ChooseCityActivity中选择城市了。

首先把这个Activity和我们之前新建的Layout联系起来,

public class ChooseCityActivity extends Activity
{
    @ViewInject( R.id.choose_key )
    private EditText edtKey;

    @ViewInject( R.id.choose_list )
    private ListView lstCity;

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

        ViewUtils.inject( this );
    }
}

 

 

再回想一下我们的需求:输入关键字后,在列表中显示相应的城市

这需要我们监听文本框的输入事件,可以这么做:

public class ChooseCityActivity extends Activity
{
    @ViewInject( R.id.choose_key )
    private EditText edtKey;

    @ViewInject( R.id.choose_list )
    private ListView lstCity;

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

        ViewUtils.inject( this );

        edtKey.addTextChangedListener( new TextFilter() );
    }

    private void search( String key )
    {
    }

    class TextFilter implements 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 )
        {
            String key = edtKey.getText().toString();
            search( key );
        }

        @Override
        public void afterTextChanged( Editable s )
        {
        }
    }
}

 

给EditText添加一个TextWatcher事件,就可以监听它的文本变化,当文本变化后,会调用search方法,这个方法将会查询数据库,并且把查询结果显示到ListView中。

 

将会用到数据库查询操作,联想到之前我们已经进行过存储操作了,我们可以把在Application里用到的DbUtils公开出来,在WeatherApplication添加方法:

    public DbUtils getDbUtil()
    {
        if( dbUtils == null )
        {
            dbUtils = DbUtils.create( this );
        }

        return dbUtils;
    }

 

 

关于如何把数据显示到ListView中,相信大家还记得之前如何把天气显示出来的吧。

新建一个Layout,名为item_city:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <TextView
        android:id="@+id/item_city"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:layout_margin="15dp"
        android:textColor="#000000"
        android:textSize="16sp" />

</RelativeLayout>

 

 

然后新建一个Adapter,名为CityAdapter:

public class CityAdapter extends BaseAdapter
{
    private List<CityBean> citys;
    private LayoutInflater inflater;

    public CityAdapter( Context context, List<CityBean> citys )
    {
        this.citys = citys;
        inflater = LayoutInflater.from( context );
    }

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

    @Override
    public Object getItem( int position )
    {
        return citys.get( position );
    }

    @Override
    public long getItemId( int position )
    {
        return position;
    }

    @Override
    public View getView( int position, View convertView, ViewGroup parent )
    {
        convertView = inflater.inflate( R.layout.item_city, null );

        CityBean bean = (CityBean)getItem( position );

        TextView txtCity = (TextView)convertView.findViewById( R.id.item_city );
        txtCity.setText( bean.getCityName() );

        return convertView;
    }
}

 

 

最后修改ChooseCityActivity的search方法:

    private void search( String key )
    {
        DbUtils dbUtils = WeatherApplication.getInstance().getDbUtil();
        try
        {
            List<CityBean> citys = dbUtils.findAll( Selector.from( CityBean.class ).where( "cityName", "like", "%" + key + "%" ) );
            CityAdapter adapter = new CityAdapter( getApplicationContext(), citys );
            lstCity.setAdapter( adapter );
        }
        catch( DbException e )
        {
            e.printStackTrace();
        }
    }

 

这个时候的ChooseCityActivity是这样的:

public class ChooseCityActivity extends Activity
{
    @ViewInject( R.id.choose_key )
    private EditText edtKey;

    @ViewInject( R.id.choose_list )
    private ListView lstCity;

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

        ViewUtils.inject( this );

        edtKey.addTextChangedListener( new TextFilter() );
    }

    private void search( String key )
    {
        DbUtils dbUtils = WeatherApplication.getInstance().getDbUtil();
        try
        {
            List<CityBean> citys = dbUtils.findAll( Selector.from( CityBean.class ).where( "cityName", "like", "%" + key + "%" ) );
            CityAdapter adapter = new CityAdapter( getApplicationContext(), citys );
            lstCity.setAdapter( adapter );
        }
        catch( DbException e )
        {
            e.printStackTrace();
        }
    }

    class TextFilter implements 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 )
        {
            String key = edtKey.getText().toString();
            search( key );
        }

        @Override
        public void afterTextChanged( Editable s )
        {
        }
    }
}

 

来运行一下吧,点击“添加城市”,在输入框中输入文字后,列表是不是有了内容了?

我的是这样的:

device-2015-01-25-145816

 

到这里,我们的工作就完成了一多半了,剩下的就是把选择的城市回传给MainActivity,并且更新天气数据。

 

再接再厉,我们把最后这部分完成再休息。

 

关于如何把选择的城市回传,之前已经了解了,这次实践一下:

    @OnItemClick( R.id.choose_list )
    public void onItemClick( AdapterView<?> parent, View view, int position, long id )
    {
        CityBean cityBean = (CityBean)parent.getAdapter().getItem( position );

        Intent intent = new Intent();
        intent.putExtra( "selectedCity", cityBean.getCityName() );
        setResult( RESULT_OK, intent );
        super.finish();
    }

 

这个方法是ListView中的Item点击后触发,作用就是把选中的城市从Adapter中取出来,并且回传。

 

然后在MainActivity中修改onActivityResult方法:

    protected void onActivityResult( int requestCode, int resultCode, Intent data )
    {
        super.onActivityResult( requestCode, resultCode, data );

        if( resultCode == RESULT_OK )
        {
            String selectedCity = data.getStringExtra( "selectedCity" );
            getWeather( selectedCity );
        }
    }

在这里先判断了一下resultCode时候是正确返回,然后取出来城市并且调用了getWeather方法获取天气。

 

打完收工,运行一下吧。

 

有没有发现这个情况:

选择了别的城市后,再返回回来,天气好像是发生了变化,但是标题上还是所在地的名字,为什么会有这个情况呢?我们明明在getWeather方法中设置了标题啊。

 

别急,让我们回想一下Activity的生命周期中的第3条:

>> 3. Activity重新获得焦点的时候,会依次执行onRestart、onStart和onResume

当返回到MainActivity的时候,这个顺序有发生了一点变化,它会这样执行:

onActivityResult -> onRestart -> onStart -> onResume

看到了吧,onActivityResult是最先执行,这个时候我们调用getWeather会被onStart调用的getWeather给覆盖掉,怎么解决呢?

我这里有两种办法:

1. 我们不在onStart中获取天气,而在onCreate中获取

2. 修改一下getWeather,把城市作为类的成员变量,而不是方法参数,这样保证城市的一致

我们先采用第二种办法吧。

public class MainActivity extends Activity
{
    @ViewInject( R.id.weather_list )
    private ListView lstWeather;

    private WeatherAdapter adapter;
    private BaiduData data;

    private List<WeatherDataBean> datas;

    private LocationClient mLocationClient;
    private BDLocationListener myListener;

    private String city;

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

        Log.v( "WeatherAPP", "onCreate" );

        ViewUtils.inject( this );

        datas = new ArrayList<WeatherDataBean>();
        adapter = new WeatherAdapter( getApplicationContext(), datas );
        lstWeather.setAdapter( adapter );

        initLocationClient();
        mLocationClient.start();
    }

    @Override
    public boolean onCreateOptionsMenu( Menu menu )
    {
        super.onCreateOptionsMenu( menu );
        menu.add( Menu.NONE, Menu.FIRST + 1, 0, "添加城市" ).setShowAsAction( MenuItem.SHOW_AS_ACTION_ALWAYS );
        return true;
    }

    @Override
    public boolean onOptionsItemSelected( MenuItem item )
    {
        if( item.getItemId() == Menu.FIRST + 1 )
        {
            Intent intent = new Intent( getApplicationContext(), ChooseCityActivity.class );
            intent.putExtra( "key", "value" );
            startActivityForResult( intent, 99 );
        }

        return super.onOptionsItemSelected( item );
    }

    @Override
    protected void onActivityResult( int requestCode, int resultCode, Intent data )
    {
        super.onActivityResult( requestCode, resultCode, data );

        if( resultCode == RESULT_OK )
        {
            city = data.getStringExtra( "selectedCity" );
        }
    }

    private void getWeather()
    {
        setTitle( city + "天气" );

        HttpUtils http = new HttpUtils();

        RequestParams params = new RequestParams();
        params.addQueryStringParameter( "location", city );
        params.addQueryStringParameter( "output", "json" );
        params.addQueryStringParameter( "ak", "YknGmxIoPugT7YrNrG955YLS" );

        http.send( HttpMethod.GET, "http://api.map.baidu.com/telematics/v3/weather", params, new RequestCallBack<String>()
        {
            @Override
            public void onSuccess( ResponseInfo<String> responseInfo )
            {
                String weather = responseInfo.result;

                Gson gson = new Gson();
                data = gson.fromJson( weather, BaiduData.class );

                datas.clear();
                datas.addAll( data.getResults().get( 0 ).getWeather_data() );
                adapter.notifyDataSetChanged();

                Log.v( "onSuccess", data.toString() );
            }

            @Override
            public void onFailure( HttpException arg0, String arg1 )
            {
                Log.v( "onFailure", arg1 );
            }
        } );
    }

    private void initLocationClient()
    {
        mLocationClient = new LocationClient( getApplicationContext() ); // 声明LocationClient类
        myListener = new MyLocationListener();
        LocationClientOption option = new LocationClientOption();
        option.setLocationMode( LocationMode.Hight_Accuracy );
        option.setIsNeedAddress( true );
        mLocationClient.setLocOption( option );
        mLocationClient.registerLocationListener( myListener );
    }

    @Override
    protected void onStop()
    {
        Log.v( "WeatherAPP", "onStop" );
        super.onStop();
        mLocationClient.stop();
    }

    @Override
    protected void onPause()
    {
        Log.v( "WeatherAPP", "onPause" );
        super.onPause();
    }

    @Override
    protected void onRestart()
    {
        Log.v( "WeatherAPP", "onRestart" );
        super.onRestart();
    }

    @Override
    protected void onResume()
    {
        Log.v( "WeatherAPP", "onResume" );
        super.onResume();
    }

    @Override
    protected void onStart()
    {
        Log.v( "WeatherAPP", "onStart" );
        super.onStart();

        if( city == null || city.length() == 0 )
        {
            city = readCity();
        }

        if( city != null && city.length() > 0 )
        {
            getWeather();
        }
    }

    @Override
    protected void onDestroy()
    {
        Log.v( "WeatherAPP", "onDestroy" );
        super.onDestroy();
    }

    public class MyLocationListener implements BDLocationListener
    {
        @Override
        public void onReceiveLocation( BDLocation location )
        {
            city = location.getCity();

            String localCity = readCity();
            if( !localCity.equals( city ) )
            {
                saveCity( city );
                getWeather();
            }
        }
    }

    private void saveCity( String city )
    {
        SharedPreferences sharedPreferences = getSharedPreferences( "weather", Context.MODE_PRIVATE );
        Editor editor = sharedPreferences.edit();
        editor.putString( "city", city );
        editor.commit();
    }

    private String readCity()
    {
        SharedPreferences sharedPreferences = getSharedPreferences( "weather", Context.MODE_PRIVATE );
        return sharedPreferences.getString( "city", "" );
    }
}

 

这里修改了onStart方法:

    protected void onStart()
    {
        Log.v( "WeatherAPP", "onStart" );
        super.onStart();

        if( city == null || city.length() == 0 )
        {
            city = readCity();
        }

        if( city != null && city.length() > 0 )
        {
            getWeather();
        }
    }

如果城市为空,才获取我们在Preference中保存的城市,这是因为onActivityResult执行在前,已经把city变量赋值了,然后在 执行onStart的时候确保这个值不被覆盖。

 

大功告成了。お疲れ様です。(辛苦了)

 

就这样,天气就变成了我们选择的城市的了。

 

等等,说好的“添加城市”呢?

我想同事查看两个城市,而不是一个一个看。

别慌,怎么同时查看两个城市,我们明天继续。

 

附件是本次的工程文件,点击下载 http://pan.baidu.com/s/1bntoAGR 。

此系列文章系本人原创,如需转载,请注明出处 www.liuzhibang.cn

我们上次学习了百度定位以及SharedPreferences的使用,不知道大家有没有注意到我们新加了一个方法:

    protected void onStop()
    {
        super.onStop();
        mLocationClient.stop();
    }

 

这个方法的作用是在界面停止的时候,同时停止百度定位功能。

 

联想到我们还有onCreate,那么这两个方法是做什么用的?是什么原理呢?

这就需要我们来了解一下Activity的生命周期。

Activity生命周期

2012120122450787

Activity的整个生命周期有七个重要方法,分别是onCreate、onStart、onResume、onPause、onStop、onRestart、onDestroy,而且这七个方法在不同的状态下会有不同的触发时机,

1. Activity启动的时候,会依次执行onCreate、onStart和onResume

2. Activity失去焦点的时候,会依次执行onPause和onStop

3. Activity重新获得焦点的时候,会依次执行onRestart、onStart和onResume

4. Activity关闭的时候,会依次执行onPause、onStop和onDestroy

举个例子:

在APP已经启动的时候,如果按下Back键,那么就是第4种-关闭的情况,会依次执行onPause、onStop和onDestroy,

按下Home键,那么就是第2种-失去焦点的情况,会依次执行onPause和onStop,这个时候如果再次启动APP,就会是按照第3种-重新获得焦点的情况,会依次执行onRestart、onStart和onResume。

为了验证这一点,我们修改一下MainActivity.java,添加以下方法:

    @Override
    protected void onPause()
    {
        Log.v( "WeatherAPP", "onPause" );
        super.onPause();
    }

    @Override
    protected void onRestart()
    {
        Log.v( "WeatherAPP", "onRestart" );
        super.onRestart();
    }

    @Override
    protected void onResume()
    {
        Log.v( "WeatherAPP", "onResume" );
        super.onResume();
    }

    @Override
    protected void onStart()
    {
        Log.v( "WeatherAPP", "onStart" );
        super.onStart();
    }

    @Override
    protected void onDestroy()
    {
        Log.v( "WeatherAPP", "onDestroy" );
        super.onDestroy();
    }

 

 

并且在onCreate和onStop方法内加入分别加入:

        Log.v( "WeatherAPP", "onCreate" );
	Log.v( "WeatherAPP", "onStop" );

 

 

然后运行程序,试着重复以上操作,并且在Logcat View中查看相应的Log。

这里说一点小技巧,点击Logcat View左上角的绿色加号,可以添加自定义的日志过滤器,我这里就是用了这样的功能。

QQ截图20140927194650

QQ截图20140927194550

 

在明白了Activity的生命周期后,它们在实际的APP中具体怎么应用?

那么,举一些例子。

1. 如果我们的预报天气APP需要在用户每次重新可见的时候都获取最新天气,那么调用获取天气相关的代码就需要放置到onResume方法中

2. 另外一种情况,我们的APP已经在前台可见了,这时候来了电话,就变得不可见了,之后挂了电话,又重新可见了,这个时候通常是不需要重新获取数据的,那么调用获取天气相关的代码就需要放置到onStart方法中

3. 最简单的情况,我们只需要在启动的时候获取天气,那么就只需要在onCreate方法中执行

所以呢,技术不是问题,一切都需要根据实际的需要来决定我们的程序应该如何实现。

 

以上是简单介绍了一下Activity的生命周期,大家可以在实践中慢慢摸索,并且以上介绍的都只是基础内容,高阶一点的内容我们将在之后的学习中慢慢接触。

 

在了解了生命周期后,是不是要对我们的APP做些修改呢,嗯,就按照第2种情况修改吧。

所要做的只是把下面这段代码从onCreate方法移到onStart中。

        String city = readCity();
        if( city != null && city.length() > 0 )
        {
            getWeather( city );
        }

 

看看结果是不是想要的呢。

 

想必练习到这里,大家也都累了,理论知识真是恼人,不过确实是我们所必须的,只有经过理论武装的知识才能发挥出最大作用。

今天就到这里吧,各位辛苦了。

明天是周末,会有很多的内容,请大家期待!

 

此系列文章系本人原创,如需转载,请注明出处 www.liuzhibang.cn