Android项目的目录结构(熟悉)
- Activity:应用被打开时显示的界面
- src:项目代码
- R.java:项目中所有资源文件的资源id
- Android.jar:Android的jar包,导入此包方可使用Android的api
- libs:导入第三方jar包
- assets:存放资源文件,比方说mp3、视频文件
- bin:存放编译打包后的文件
- res:存放资源文件,存放在此文件夹下的所有资源文件都会生成资源id
- drawable:存放图片资源
- layout:存放布局文件,把布局文件通过资源id指定给activity,界面就会显示出该布局文件定义的布局
- menu:定义菜单的样式
- Strings.xml:存放字符串资源,每个资源都会有一个资源id
Android的配置文件(清单文件)(熟悉)
指定应用的包名
package="com.itheima.helloworld"
- data/data/com.itheima.helloworld(上面代码指定的包名)
- 应用生成的文件都会存放在此路径下
Android的四大组件在使用前全部需要在清单文件中配置
- 的配置对整个应用生效
- 的配置对该activity生效
DDMS(掌握)
- Dalvik debug monitor service
- Dalvik调试监控服务
常用的adb指令(掌握)
Android debug bridge:安卓调试桥
- adb start-server:启动adb进程
- adb kill-server:杀死adb进程
- adb devices:查看当前与开发环境连接的设备,此命令也可以启动adb进程
- adb install XXX.apk:往模拟器安装apk
- adb uninstall 包名:删除模拟器中的应用
- adb shell:进入linux命令行
- ps:查看运行进程
- ls:查看当前目录下的文件结构
- netstat -ano:查看占用端口的进程
电话拨号器(掌握)
功能:用户输入一个号码,点击拨打按钮,启动系统打电话的应用把号码拨打出去
1. 定义布局
组件必须设置宽高,否则不能通过编译
android:layout_width="wrap_content" android:layout_height="wrap_content"
如果要在java代码中操作某个组件,则组件需要设置id,这样才能在代码中通过id拿到这个组件
android:id="@+id/et_phone"
2. 给按钮设置点击侦听
给按钮设置侦听
//通过id拿到按钮对象 Button bt_call = (Button) findViewById(R.id.bt_call); //给按钮设置点击 bt_call.setOnClickListener(new MyListener());
3. 得到用户输入的号码
//得到用户输入的号码,先拿到输入框组件
EditText et_phone = (EditText) findViewById(R.id.et_phone);
String phone = et_phone.getText().toString();
4. 把号码打出去
- Android系统中基于动作机制,来调用系统的应用,你告诉系统你想做什么动作,系统就会把能做这个动作的应用给你,如果没有这个应用,会抛异常
设置动作,通过意图告知系统
//把号码打出去 //先创建一个意图对象 Intent intent = new Intent(); //设置动作,打电话 intent.setAction(Intent.ACTION_CALL); intent.setData(Uri.parse("tel:" + phone)); //把意图告诉系统 startActivity(intent);
添加权限
<uses-permission android:name="android.permission.CALL_PHONE"/>
点击事件的四种写法(掌握)
第一种
定义一个MyListener实现onClickListener接口
Button bt1 = (Button) findViewById(R.id.bt1); bt1.setOnClickListener(new MyListener());
第二种
定义一个匿名内部类实现onClickListener接口
Button bt2 = (Button) findViewById(R.id.bt2); bt2.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { System.out.println("第二种"); } });
第三种
让当前activity实现onClickListener接口
Button bt3 = (Button) findViewById(R.id.bt3); bt3.setOnClickListener(this);
第四种
给Button节点设置onClick属性,
android:onClick="click"
然后在activity中定义跟该属性值同名的方法
public void click(View v){ System.out.println("第四种"); }
短信发送器(掌握)
功能:用户输入号码和短信内容,点击发送按钮,调用短信api把短信发送给指定号码
1. 定义布局
输入框的提示
android:hint="请输入号码"
2. 完成点击事件
- 先给Button组件设置onClick属性
-
onClick=”send” - 在Activity中定义此方法
-
public void send(View v){}
3. 获取到用户输入的号码和内容
EditText et_phone = (EditText) findViewById(R.id.et_phone);
EditText et_content = (EditText) findViewById(R.id.et_content);
String phone = et_phone.getText().toString();
String content = et_content.getText().toString();
4. 调用发送短信的api
//调用发送短信的api
SmsManager sm = SmsManager.getDefault();
//发送短信
sm.sendTextMessage(phone, null, content, null, null);
* 添加权限
<uses-permission android:name="android.permission.SEND_SMS"/>
* 如果短信过长,需要拆分
List<String> smss = sm.divideMessage(content);
常用布局
线性布局
- LinearLayout
指定各个节点的排列方向
android:orientation="horizontal"
设置右对齐
android:layout_gravity="right"
- 当竖直布局时,只能左右对齐和水平居中,顶部底部对齐竖直居中无效
- 当水平布局时,只能顶部底部对齐和竖直居中
- 使用match_parent时注意不要把其他组件顶出去
线性布局非常重要的一个属性:权重
android:layout_weight="1"
- 权重:按比例分配屏幕的剩余宽度或者高度
常见布局
相对布局(掌握)
RelativeLayout
- 组件默认左对齐、顶部对齐
设置组件在指定组件的右边
android:layout_toRightOf="@id/tv1"
设置在指定组件的下边
android:layout_below="@id/tv1"
设置右对齐父元素
android:layout_alignParentRight="true"
设置与指定组件右对齐
android:layout_alignRight="@id/tv1"
线性布局(掌握)
LinearLayout
指定各个节点的排列方向
android:orientation="horizontal"
设置右对齐
android:layout_gravity="right"
- 当竖直布局时,只能左右对齐和水平居中,顶部底部对齐竖直居中无效
- 当水平布局时,只能顶部底部对齐和竖直居中
- 使用match_parent时注意不要把其他组件顶出去
线性布局非常重要的一个属性:权重
android:layout_weight="1"
- 权重:按比例分配屏幕的剩余宽度或者高度
帧布局(掌握)
FrameLayout
- 默认组件都是左对齐和顶部对齐,每个组件相当于一个div
可以设置上下左右对齐,水平竖直居中,设置方式与线性布局一样
android:layout_gravity="bottom"
- 不能相对于其他组件布局
表格布局(熟悉)
TableLayout
- 每个节点是一行,它的每个子节点是一列
表格布局中的节点可以不设置宽高,因为设置了也无效
- 根节点的子节点宽为匹配父元素,高为包裹内容
- 节点的子节点宽为包裹内容,高为包裹内容
- 以上默认属性无法修改
根节点中可以设置以下属性,表示让第1列拉伸填满屏幕宽度的剩余空间
android:stretchColumns="1"
绝对布局(熟悉)
AbsoluteLayout
直接指定组件的x、y坐标
android:layout_x="144dp" android:layout_y="154dp"
logcat(掌握)
- 日志信息总共分为5个等级
- verbose
- debug
- info
- warn
- error
- 定义过滤器方便查看
- System.out.print输出的日志级别是info,tag是System.out
Android提供的日志输出api
Log.v(TAG, "加油吧,童鞋们"); Log.d(TAG, "加油吧,童鞋们"); Log.i(TAG, "加油吧,童鞋们"); Log.w(TAG, "加油吧,童鞋们"); Log.e(TAG, "加油吧,童鞋们");
文件读写操作
- Ram内存:运行内存,相当于电脑的内存
- Rom内存:内部存储空间,相当于电脑的硬盘
- sd卡:外部存储空间,相当于电脑的移动硬盘
在内部存储空间中读写文件(掌握)
小案例:用户输入账号密码,勾选“记住账号密码”,点击登录按钮,登录的同时持久化保存账号和密码
1. 定义布局
2. 完成按钮的点击事件
弹土司提示用户登录成功
Toast.makeText(this, "登录成功", Toast.LENGTH_SHORT).show();
3. 拿到用户输入的数据
判断用户是否勾选保存账号密码
CheckBox cb = (CheckBox) findViewById(R.id.cb); if(cb.isChecked()){ }
4. 开启io流把文件写入内部存储
直接开启文件输出流写数据
//持久化保存数据 File file = new File("data/data/com.itheima.rwinrom/info.txt"); FileOutputStream fos = new FileOutputStream(file); fos.write((name + "##" + pass).getBytes()); fos.close();
读取数据前先检测文件是否存在
if(file.exists())
读取保存的数据,也是直接开文件输入流读取
File file = new File("data/data/com.itheima.rwinrom/info.txt"); FileInputStream fis = new FileInputStream(file); //把字节流转换成字符流 BufferedReader br = new BufferedReader(new InputStreamReader(fis)); String text = br.readLine(); String[] s = text.split("##");
读取到数据之后,回显至输入框
et_name.setText(s[0]); et_pass.setText(s[1]);
- 应用只能在自己的包名目录下创建文件,不能到别人家去创建
直接复制项目
- 需要改动的地方:
- 项目名字
- 应用包名
- R文件重新导包
使用路径api读写文件(掌握)
- getFilesDir()得到的file对象的路径是data/data/com.itheima.rwinrom2/files
- 存放在这个路径下的文件,只要你不删,它就一直在
getCacheDir()得到的file对象的路径是data/data/com.itheima.rwinrom2/cache
- 存放在这个路径下的文件,当内存不足时,有可能被删除
系统管理应用界面的清除缓存,会清除cache文件夹下的东西,清除数据,会清除整个包名目录下的东西
在外部存储读写数据
sd卡的路径(掌握)
- 2.2之前,sd卡路径:sdcard
- 4.3之前,sd卡路径:mnt/sdcard
4.3开始,sd卡路径:storage/sdcard
最简单的打开sd卡的方式
File file = new File("sdcard/info.txt");
写sd卡需要权限
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
读sd卡,在4.0之前不需要权限,4.0之后可以设置为需要
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
使用api获得sd卡的真实路径,部分手机品牌会更改sd卡的路径
Environment.getExternalStorageDirectory()
判断sd卡是否准备就绪
if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED))
查看源代码查找获取sd卡剩余容量的代码(掌握)
- 导入Settings项目
查找“可用空间”得到
<string name="memory_available" msgid="418542433817289474">"可用空间"</string>
查找”memory_available”,得到
<Preference android:key="memory_sd_avail" style="?android:attr/preferenceInformationStyle" android:title="@string/memory_available" android:summary="00"/>
查找”memory_sd_avail”,得到
//这个字符串就是sd卡剩余容量 formatSize(availableBlocks * blockSize) + readOnly //这两个参数相乘,得到sd卡以字节为单位的剩余容量 availableBlocks * blockSize
存储设备会被分为若干个区块,每个区块有固定的大小
- 区块大小 * 区块数量 等于 存储设备的总大小
Linux文件的访问权限(掌握)
- 在Android中,每一个应用是一个独立的用户
- drwxrwxrwx
- 第1位:d表示文件夹,-表示文件
- 第2-4位:rwx,表示这个文件的拥有者用户(owner)对该文件的权限
- r:读
- w:写
- x:执行
- 第5-7位:rwx,表示跟文件拥有者用户同组的用户(grouper)对该文件的权限
- 第8-10位:rwx,表示其他用户组的用户(other)对该文件的权限
openFileOutput的四种模式(熟悉)
- MODE_PRIVATE:-rw-rw—-
- MODE_APPEND:-rw-rw—-
- MODE_WORLD_WRITEABLE:-rw-rw–w-
- MODE_WORLD_READABLE:-rw-rw-r–
SharedPreference(掌握)
用SharedPreference存储账号密码
往SharedPreference里写数据
//拿到一个SharedPreference对象 SharedPreferences sp = getSharedPreferences("config", MODE_PRIVATE); //拿到编辑器 Editor ed = sp.edit(); //写数据 ed.putBoolean("name", name); ed.commit();
从SharedPreference里取数据
SharedPreferences sp = getSharedPreferences("config", MODE_PRIVATE); //从SharedPreference里取数据 String name = sp.getBoolean("name", "");
生成XML文件备份短信
- 创建几个虚拟的短信对象,存在list中
- 备份数据通常都是备份至sd卡
使用StringBuffer拼接字符串(了解)
把整个xml文件所有节点append到sb对象里
sb.append("<?xml version='1.0' encoding='utf-8' standalone='yes' ?>"); //添加smss的开始节点 sb.append("<smss>"); .......
把sb写到输出流中
fos.write(sb.toString().getBytes());
使用XMl序列化器生成xml文件(掌握)
得到xml序列化器对象
XmlSerializer xs = Xml.newSerializer();
给序列化器设置输出流
File file = new File(Environment.getExternalStorageDirectory(), "backupsms.xml"); FileOutputStream fos = new FileOutputStream(file); //给序列化器指定好输出流 xs.setOutput(fos, "utf-8");
开始生成xml文件
xs.startDocument("utf-8", true); xs.startTag(null, "smss"); ......
Pull解析xml文件(掌握)
- 先自己写一个xml文件,存一些天气信息
拿到xml文件
InputStream is = getClassLoader().getResourceAsStream("weather.xml");
拿到pull解析器
XmlPullParser xp = Xml.newPullParser();
开始解析
拿到指针所在当前节点的事件类型
int type = xp.getEventType();
事件类型主要有五种
- START_DOCUMENT:xml头的事件类型
- END_DOCUMENT:xml尾的事件类型
- START_TAG:开始节点的事件类型
- END_TAG:结束节点的事件类型
- TEXT:文本节点的事件类型
如果获取到的事件类型不是END_DOCUMENT,就说明解析还没有完成,如果是,解析完成,while循环结束
while(type != XmlPullParser.END_DOCUMENT)
当我们解析到不同节点时,需要进行不同的操作,所以判断一下当前节点的name
- 当解析到weather的开始节点时,new出list
- 当解析到city的开始节点时,创建city对象,创建对象是为了更方便的保存即将解析到的文本
当解析到name开始节点时,获取下一个节点的文本内容,temp、pm也是一样
case XmlPullParser.START_TAG: //获取当前节点的名字 if("weather".equals(xp.getName())){ citys = new ArrayList<City>(); } else if("city".equals(xp.getName())){ city = new City(); } else if("name".equals(xp.getName())){ //获取当前节点的下一个节点的文本 String name = xp.nextText(); city.setName(name); } else if("temp".equals(xp.getName())){ String temp = xp.nextText(); city.setTemp(temp); } else if("pm".equals(xp.getName())){ String pm = xp.nextText(); city.setPm(pm); } break;
当解析到city的结束节点时,说明city的三个子节点已经全部解析完了,把city对象添加至list
case XmlPullParser.END_TAG: if("city".equals(xp.getName())){ citys.add(city); }
测试(了解)
- 黑盒测试
- 测试逻辑业务
白盒测试
- 测试逻辑方法
根据测试粒度
- 方法测试:function test
- 单元测试:unit test
- 集成测试:integration test
- 系统测试:system test
根据测试暴力程度
- 冒烟测试:smoke test
- 压力测试:pressure test
单元测试junit(熟悉)
定义一个类继承AndroidTestCase,在类中定义方法,即可测试该方法
在指定指令集时,targetPackage指定你要测试的应用的包名
<instrumentation android:name="android.test.InstrumentationTestRunner" android:targetPackage="com.itheima.junit" ></instrumentation>
定义使用的类库
<uses-library android:name="android.test.runner"></uses-library>
断言的作用,检测运行结果和预期是否一致
- 如果应用出现异常,会抛给测试框架
SQLite数据库(掌握)
- 轻量级关系型数据库
创建数据库需要使用的api:SQLiteOpenHelper
必须定义一个构造方法:
//arg1:数据库文件的名字 //arg2:游标工厂 //arg3:数据库版本 public MyOpenHelper(Context context, String name, CursorFactory factory, int version){ }
- 数据库被创建时会调用:onCreate方法
- 数据库升级时会调用:onUpgrade方法
创建数据库
//创建OpenHelper对象
MyOpenHelper oh = new MyOpenHelper(getContext(), "person.db", null, 1);
//获得数据库对象,如果数据库不存在,先创建数据库,后获得,如果存在,则直接获得
SQLiteDatabase db = oh.getWritableDatabase();
- getWritableDatabase():打开可读写的数据库
- getReadableDatabase():在磁盘空间不足时打开只读数据库,否则打开可读写数据库
在创建数据库时创建表
public void onCreate(SQLiteDatabase db) { // TODO Auto-generated method stub db.execSQL("create table person (_id integer primary key autoincrement, name char(10), phone char(20), money integer(20))"); }
数据库的增删改查(掌握)
SQL语句
- insert into person (name, phone, money) values (‘张三’, ‘159874611’, 2000);
- delete from person where name = ‘李四’ and _id = 4;
- update person set money = 6000 where name = ‘李四’;
- select name, phone from person where name = ‘张三’;
执行SQL语句实现增删改查
//插入
db.execSQL("insert into person (name, phone, money) values (?, ?, ?);", new Object[]{"张三", 15987461, 75000});
//查找
Cursor cs = db.rawQuery("select _id, name, money from person where name = ?;", new String[]{"张三"});
* 测试方法执行前会调用此方法
protected void setUp() throws Exception {
super.setUp();
// 获取虚拟上下文对象
oh = new MyOpenHelper(getContext(), "people.db", null, 1);
}
* 测试方法执行后会调用此方法:tearDown()
使用api实现增删改查
插入
//以键值对的形式保存要存入数据库的数据 ContentValues cv = new ContentValues(); cv.put("name", "刘能"); cv.put("phone", 1651646); cv.put("money", 3500); //返回值是改行的主键,如果出错返回-1 long i = db.insert("person", null, cv);
删除
//返回值是删除的行数 int i = db.delete("person", "_id = ? and name = ?", new String[]{"1", "张三"});
修改
ContentValues cv = new ContentValues(); cv.put("money", 25000); int i = db.update("person", cv, "name = ?", new String[]{"赵四"});
查询
//arg1:要查询的字段 //arg2:查询条件 //arg3:填充查询条件的占位符 Cursor cs = db.query("person", new String[]{"name", "money"}, "name = ?", new String[]{"张三"}, null, null, null); while(cs.moveToNext()){ // 获取指定列的索引值 String name = cs.getString(cs.getColumnIndex("name")); String money = cs.getString(cs.getColumnIndex("money")); System.out.println(name + ";" + money); }
事务
- 保证多条SQL语句要么同时成功,要么同时失败
- 最常见案例:银行转账
事务api
try { //开启事务 db.beginTransaction(); ........... //设置事务执行成功 db.setTransactionSuccessful(); } finally{ //关闭事务 //如果此时已经设置事务执行成功,则sql语句生效,否则不生效 db.endTransaction(); }
把数据库的数据显示至屏幕(了解)
任意插入一些数据
- 定义业务bean:Person.java
读取数据库的所有数据
Cursor cs = db.query(“person”, null, null, null, null, null, null);
while(cs.moveToNext()){
String name = cs.getString(cs.getColumnIndex(“name”));
String phone = cs.getString(cs.getColumnIndex(“phone”));
String money = cs.getString(cs.getColumnIndex(“money”));
//把读到的数据封装至Person对象
Person p = new Person(name, phone, money);
//把person对象保存至集合中
people.add(p);
}把集合中的数据显示至屏幕
LinearLayout ll = (LinearLayout) findViewById(R.id.ll);
for(Person p : people){
//创建TextView,每条数据用一个文本框显示
TextView tv = new TextView(this);
tv.setText(p.toString());
//把文本框设置为ll的子节点
ll.addView(tv);
}分页查询
Cursor cs = db.query(“person”, null, null, null, null, null, null, “0, 10”);
ListView(掌握)
- 用于显示列表
- MVC结构
- M:model模型层,要显示的数据 ————people集合
- V:view视图层,用户看到的界面 ————ListView
- c:control控制层,操作数据如何显示 ————adapter对象
- 每一个条目都是一个View对象
BaseAdapter
必须实现的两个方法
第一个
//系统调用此方法,用来获知模型层有多少条数据 @Override public int getCount() { return people.size(); }
第二个
//系统调用此方法,获取要显示至ListView的View对象 //position:是return的View对象所对应的数据在集合中的位置 @Override public View getView(int position, View convertView, ViewGroup parent) { System.out.println("getView方法调用" + position); TextView tv = new TextView(MainActivity.this); //拿到集合中的元素 Person p = people.get(position); tv.setText(p.toString()); //把TextView的对象返回出去,它会变成ListView的条目 return tv; }
- 屏幕上能显示多少个条目,getView方法就会被调用多少次,屏幕向下滑动时,getView会继续被调用,创建更多的View对象显示至屏幕
条目的缓存
- 当条目划出屏幕时,系统会把该条目缓存至内存,当该条目再次进入屏幕,系统在重新调用getView时会把缓存的条目作为convertView参数传入,但是传入的条目不一定是之前被缓存的该条目,即系统有可能在调用getView方法获取第一个条目时,传入任意一个条目的缓存
ArrayAdapter(熟悉)
在条目中显示一个字符串
String[] objects = new String[]{ "张三", "李四", "王五" }; ListView lv = (ListView) findViewById(R.id.lv); //arg1:指定要填充的布局文件 //arg2:指定文本显示至哪一个文本框内 lv.setAdapter(new ArrayAdapter<String>(this, R.layout.item_array, R.id.tv_name, objects));
SimpleAdapter(熟悉)
- 可在条目中显示多种数据
要显示的数据封装在List中,集合的每一个元素存放的是一个条目会显示的数据,因为可能会有多种数据,而集合的泛型只能指定一种数据,所以把数据先存放在Map中,在把Map放入List中
List<Map<String, Object>> data = new ArrayList<Map<String,Object>>(); //张三的头像和名字是两种类型的数据,先封装至Map Map<String, Object> map1 = new HashMap<String, Object>(); map1.put("name", "张三"); map1.put("image", R.drawable.photo1); //把Map封装至List data.add(map1); ...
通过两个数组的下标对应指定数据存放入对应的控件中
lv.setAdapter(new SimpleAdapter(this, data, R.layout.item_array,
new String[]{“name”, “image”}, new int[]{R.id.tv_name, R.id.iv_photo}));
网络图片查看器(掌握)
- 确定图片的网址
发送http请求
//1.使用网址构造一个URL对象
URL url = new URL(address);
//2.获取连接对象,并没有建立连接
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
//3.设置一些属性
//设置连接和读取超时
conn.setConnectTimeout(5000);
conn.setReadTimeout(5000);
//设置请求方法,注意必须大写
conn.setRequestMethod(“GET”);
//建立连接,发送get请求
//conn.connect();
//建立连接,然后获取响应吗,200说明请求成功
conn.getResponseCode();服务器的图片是以流的形式返回给浏览器的
//拿到服务器返回的输入流
InputStream is = conn.getInputStream();
//把流里的数据读取出来,并构造成图片
Bitmap bm = BitmapFactory.decodeStream(is);把图片设置为ImageView的显示内容
ImageView iv = (ImageView) findViewById(R.id.iv); iv.setImageBitmap(bm);
- 添加权限
主线程不能被阻塞
- 在Android中,主线程被阻塞会导致应用不能刷新ui界面,不能响应用户操作,用户体验将非常差
- 主线程阻塞时间过长,系统会抛出ANR异常
- ANR:Application Not Response;应用无响应
- 任何耗时操作都不可以写在主线程
- 因为网络交互属于耗时操作,如果网速很慢,代码会阻塞,所以网络交互的代码不能运行在主线程
只有主线程能刷新ui
- 刷新ui的代码只能运行在主线程,运行在子线程是没有任何效果的
- 如果需要在子线程中刷新ui,使用消息队列机制
- 主线程也叫ui线程
消息队列(重点掌握)
- 主线程创建时,系统会同时创建消息队列对象(MessageQueue)和消息轮询器对象(Looper)
- 轮询器的作用,就是不停的检测消息队列中是否有消息(Message)
- Looper一旦发现Message Queue中有消息,就会把消息取出,然后把消息扔给Handler对象,Handler会调用自己的handleMessage方法来处理这条消息
- handleMessage方法运行在主线程
主线程创建时,消息队列和轮询器对象就会被创建,但是消息处理器对象,需要使用时,自行创建
//消息队列 Handler handler = new Handler(){ //主线程中有一个消息轮询器looper,不断检测消息队列中是否有新消息,如果发现有新消息,自动调用此方法,注意此方法是在主线程中运行的 public void handleMessage(android.os.Message msg) { } };
在子线程中使用Handler对象往消息队列里发消息
//创建消息对象 Message msg = new Message(); //消息的obj属性可以赋值任何对象,通过这个属性可以携带数据 msg.obj = bm; //what属性相当于一个标签,用于区分出不同的消息,从而运行不能的代码 msg.what = 1; //发送消息 handler.sendMessage(msg);
通过switch语句区分不同的消息
public void handleMessage(android.os.Message msg) { switch (msg.what) { //如果是1,说明属于请求成功的消息 case 1: ImageView iv = (ImageView) findViewById(R.id.iv); Bitmap bm = (Bitmap) msg.obj; iv.setImageBitmap(bm); break; case 2: Toast.makeText(MainActivity.this, "请求失败", 0).show(); break; } }
加入缓存图片的功能(熟悉)
把服务器返回的流里的数据读取出来,然后通过文件输入流写至本地文件
//1.拿到服务器返回的输入流 InputStream is = conn.getInputStream(); //2.把流里的数据读取出来,并构造成图片 FileOutputStream fos = new FileOutputStream(file); byte[] b = new byte[1024]; int len = 0; while((len = is.read(b)) != -1){ fos.write(b, 0, len); }
创建bitmap对象的代码改成
Bitmap bm = BitmapFactory.decodeFile(file.getAbsolutePath());
- 每次发送请求前检测一下在缓存中是否存在同名图片,如果存在,则读取缓存
获取开源代码的网站(熟悉)
- code.google.com
- github.com
- 在github搜索smart-image-view
- 下载开源项目smart-image-view
使用自定义组件时,标签名字要写包名
<com.loopj.android.image.SmartImageView/>
SmartImageView的使用
SmartImageView siv = (SmartImageView) findViewById(R.id.siv); siv.setImageUrl("http://192.168.1.102:8080/dd.jpg");
Html源文件查看器(掌握)
发送GET请求
URL url = new URL(path); //获取连接对象 HttpURLConnection conn = (HttpURLConnection) url.openConnection(); //设置连接属性 conn.setRequestMethod("GET"); conn.setConnectTimeout(5000); conn.setReadTimeout(5000); //建立连接,获取响应吗 if(conn.getResponseCode() == 200){ }
获取服务器返回的流,从流中把html源码读取出来
byte[] b = new byte[1024]; int len = 0; ByteArrayOutputStream bos = new ByteArrayOutputStream(); while((len = is.read(b)) != -1){ //把读到的字节先写入字节数组输出流中存起来 bos.write(b, 0, len); } //把字节数组输出流中的内容转换成字符串 //默认使用utf-8 text = new String(bos.toByteArray());
乱码的处理
乱码的出现是因为服务器和客户端码表不一致导致
//手动指定码表 text = new String(bos.toByteArray(), "gb2312");
提交数据(掌握)
GET方式提交数据
get方式提交的数据是直接拼接在url的末尾
final String path = "http://192.168.1.104/Web/servlet/CheckLogin?name=" + name + "&pass=" + pass;
发送get请求,代码和之前一样
URL url = new URL(path); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setRequestMethod("GET"); conn.setReadTimeout(5000); conn.setConnectTimeout(5000); if(conn.getResponseCode() == 200){ }
浏览器在发送请求携带数据时会对数据进行URL编码,我们写代码时也需要为中文进行URL编码
String path = "http://192.168.1.104/Web/servlet/CheckLogin?name=" + URLEncoder.encode(name) + "&pass=" + pass;
POST方式提交数据
- post提交数据是用输出流写给服务器的
协议头中多了两个属性
- Content-Type: application/x-www-form-urlencoded,描述提交的数据的mimetype
Content-Length: 32,描述提交的数据的长度
//给请求头添加post多出来的两个属性 String data = "name=" + URLEncoder.encode(name) + "&pass=" + pass; conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); conn.setRequestProperty("Content-Length", data.length() + "");
设置允许打开post请求的流
conn.setDoOutput(true);
获取连接对象的输出流,往流里写要提交给服务器的数据
OutputStream os = conn.getOutputStream(); os.write(data.getBytes());
HttpClient(掌握)
发送get请求
创建一个客户端对象
HttpClient client = new DefaultHttpClient();
创建一个get请求对象
HttpGet hg = new HttpGet(path);
发送get请求,建立连接,返回响应头对象
HttpResponse hr = client.execute(hg);
获取状态行对象,获取状态码,如果为200则说明请求成功
if(hr.getStatusLine().getStatusCode() == 200){ //拿到服务器返回的输入流 InputStream is = hr.getEntity().getContent(); String text = Utils.getTextFromStream(is); }
发送post请求
//创建一个客户端对象
HttpClient client = new DefaultHttpClient();
//创建一个post请求对象
HttpPost hp = new HttpPost(path);
往post对象里放入要提交给服务器的数据
//要提交的数据以键值对的形式存在BasicNameValuePair对象中 List<NameValuePair> parameters = new ArrayList<NameValuePair>(); BasicNameValuePair bnvp = new BasicNameValuePair("name", name); BasicNameValuePair bnvp2 = new BasicNameValuePair("pass", pass); parameters.add(bnvp); parameters.add(bnvp2); //创建实体对象,指定进行URL编码的码表 UrlEncodedFormEntity entity = new UrlEncodedFormEntity(parameters, "utf-8"); //为post请求设置实体 hp.setEntity(entity);
异步HttpClient框架(熟悉)
发送get请求
//创建异步的httpclient对象
AsyncHttpClient ahc = new AsyncHttpClient();
//发送get请求
ahc.get(path, new MyHandler());
* 注意AsyncHttpResponseHandler两个方法的调用时机
class MyHandler extends AsyncHttpResponseHandler{
//http请求成功,返回码为200,系统回调此方法
@Override
public void onSuccess(int statusCode, Header[] headers,
//responseBody的内容就是服务器返回的数据
byte[] responseBody) {
Toast.makeText(MainActivity.this, new String(responseBody), 0).show();
}
//http请求失败,返回码不为200,系统回调此方法
@Override
public void onFailure(int statusCode, Header[] headers,
byte[] responseBody, Throwable error) {
Toast.makeText(MainActivity.this, "返回码不为200", 0).show();
}
}
发送post请求
使用RequestParams对象封装要携带的数据
//创建异步httpclient对象 AsyncHttpClient ahc = new AsyncHttpClient(); //创建RequestParams封装要携带的数据 RequestParams rp = new RequestParams(); rp.add("name", name); rp.add("pass", pass); //发送post请求 ahc.post(path, rp, new MyHandler());
多线程下载(掌握)
原理:服务器CPU分配给每条线程的时间片相同,服务器带宽平均分配给每条线程,所以客户端开启的线程越多,就能抢占到更多的服务器资源
确定每条线程下载多少数据(掌握)
发送http请求至下载地址
String path = "http://192.168.1.102:8080/editplus.exe"; URL url = new URL(path); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setReadTimeout(5000); conn.setConnectTimeout(5000); conn.setRequestMethod("GET");
获取文件总长度,然后创建长度一致的临时文件
if(conn.getResponseCode() == 200){ //获得服务器流中数据的长度 int length = conn.getContentLength(); //创建一个临时文件存储下载的数据 RandomAccessFile raf = new RandomAccessFile(getFileName(path), "rwd"); //设置临时文件的大小 raf.setLength(length); raf.close();
确定线程下载多少数据
//计算每个线程下载多少数据 int blockSize = length / THREAD_COUNT;
计算每条线程下载数据的开始位置和结束位置(掌握)
for(int id = 1; id <= 3; id++){
//计算每个线程下载数据的开始位置和结束位置
int startIndex = (id - 1) * blockSize;
int endIndex = id * blockSize - 1;
if(id == THREAD_COUNT){
endIndex = length;
}
//开启线程,按照计算出来的开始结束位置开始下载数据
new DownLoadThread(startIndex, endIndex, id).start();
}
再次发送请求至下载地址,请求开始位置至结束位置的数据(掌握)
String path = "http://192.168.1.102:8080/editplus.exe";
URL url = new URL(path);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setReadTimeout(5000);
conn.setConnectTimeout(5000);
conn.setRequestMethod("GET");
//向服务器请求部分数据
conn.setRequestProperty("Range", "bytes=" + startIndex + "-" + endIndex);
conn.connect();
* 下载请求到的数据,存放至临时文件中
if(conn.getResponseCode() == 206){
InputStream is = conn.getInputStream();
RandomAccessFile raf = new RandomAccessFile(getFileName(path), "rwd");
//指定从哪个位置开始存放数据
raf.seek(startIndex);
byte[] b = new byte[1024];
int len;
while((len = is.read(b)) != -1){
raf.write(b, 0, len);
}
raf.close();
}
带断点续传的多线程下载(掌握)
定义一个int变量记录每条线程下载的数据总长度,然后加上该线程的下载开始位置,得到的结果就是下次下载时,该线程的开始位置,把得到的结果存入缓存文件
//用来记录当前线程总的下载长度 int total = 0; while((len = is.read(b)) != -1){ raf.write(b, 0, len); total += len; //每次下载都把新的下载位置写入缓存文本文件 RandomAccessFile raf2 = new RandomAccessFile(threadId + ".txt", "rwd"); raf2.write((startIndex + total + "").getBytes()); raf2.close(); }
下次下载开始时,先读取缓存文件中的值,得到的值就是该线程新的开始位置
FileInputStream fis = new FileInputStream(file); BufferedReader br = new BufferedReader(new InputStreamReader(fis)); String text = br.readLine(); int newStartIndex = Integer.parseInt(text); //把读到的值作为新的开始位置 startIndex = newStartIndex; fis.close();
三条线程都下载完毕之后,删除缓存文件
RUNNING_THREAD--; if(RUNNING_THREAD == 0){ for(int i = 0; i <= 3; i++){ File f = new File(i + ".txt"); f.delete(); } }
手机版的断点续传多线程下载器
- 把刚才的代码直接粘贴过来就能用,记得在访问文件时的路径要改成Android的目录,添加访问网络和外部存储的路径
用进度条显示下载进度(掌握)
拿到下载文件总长度时,设置进度条的最大值
//设置进度条的最大值 pb.setMax(length);
进度条需要显示三条线程的整体下载进度,所以三条线程每下载一次,就要把新下载的长度加入进度条
定义一个int全局变量,记录三条线程的总下载长度
int progress;
刷新进度条
while((len = is.read(b)) != -1){ raf.write(b, 0, len); //把当前线程本次下载的长度加到进度条里 progress += len; pb.setProgress(progress);
每次断点下载时,从新的开始位置开始下载,进度条也要从新的位置开始显示,在读取缓存文件获取新的下载开始位置时,也要处理进度条进度
FileInputStream fis = new FileInputStream(file); BufferedReader br = new BufferedReader(new InputStreamReader(fis)); String text = br.readLine(); int newStartIndex = Integer.parseInt(text); //新开始位置减去原本的开始位置,得到已经下载的数据长度 int alreadyDownload = newStartIndex - startIndex; //把已经下载的长度设置入进度条 progress += alreadyDownload;
添加文本框显示百分比进度(熟悉)
tv.setText(progress * 100 / pb.getMax() + "%");
HttpUtils框架(github上面的开源代码)的使用(熟悉)
HttpUtils本身就支持多线程断点续传,使用起来非常的方便
* 创建HttpUtils对象
HttpUtils http = new HttpUtils();
* 下载文件
http.download(url, //下载请求的网址
target, //下载的数据保存路径和文件名
true, //是否开启断点续传
true, //如果服务器响应头中包含了文件名,那么下载完毕后自动重命名
new RequestCallBack<File>() {//侦听下载状态
//下载成功此方法调用
@Override
public void onSuccess(ResponseInfo<File> arg0) {
tv.setText("下载成功" + arg0.result.getPath());
}
//下载失败此方法调用,比如文件已经下载、没有网络权限、文件访问不到,方法传入一个字符串参数告知失败原因
@Override
public void onFailure(HttpException arg0, String arg1) {
tv.setText("下载失败" + arg1);
}
//在下载过程中不断的调用,用于刷新进度条
@Override
public void onLoading(long total, long current, boolean isUploading) {
super.onLoading(total, current, isUploading);
//设置进度条总长度
pb.setMax((int) total);
//设置进度条当前进度
pb.setProgress((int) current);
tv_progress.setText(current * 100 / total + "%");
}
});
创建第二个Activity(掌握)
- 需要在清单文件中为其配置一个activity标签
标签中如果带有这个子节点,则会在系统中多创建一个快捷图标
<intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter>
- 一个应用程序可以在桌面创建多个快捷图标。
activity的名称、图标可以和应用程序的名称、图标不相同
android:icon="@drawable/ic_launcher" android:label="@string/app_name"
Activity的跳转(掌握)
Activity的跳转需要创建Intent对象,通过设置intent对象的参数指定要跳转Activity
通过设置Activity的包名和类名实现跳转,称为显式意图
通过指定动作实现跳转,称为隐式意图
显式意图(掌握)
跳转至同一项目下的另一个Activity,直接指定该Activity的字节码即可
Intent intent = new Intent(); intent.setClass(this, SecondActivity.class); startActivity(intent);
跳转至其他应用中的Activity,需要指定该应用的包名和该Activity的类名
Intent intent = new Intent(); //启动系统自带的拨号器应用 intent.setClassName("com.android.dialer", "com.android.dialer.DialtactsActivity"); startActivity(intent);
隐式意图(掌握)
隐式意图跳转至指定Activity
Intent intent = new Intent(); //启动系统自带的拨号器应用 intent.setAction(Intent.ACTION_DIAL); startActivity(intent);
要让一个Activity可以被隐式启动,需要在清单文件的activity节点中设置intent-filter子节点
<intent-filter > <action android:name="com.itheima.second"/> <data android:scheme="asd" android:mimeType="aa/bb"/> <category android:name="android.intent.category.DEFAULT"/> </intent-filter>
- action 指定动作(可以自定义,可以使用系统自带的)
- data 指定数据(操作什么内容)
- category 类别 (默认类别,机顶盒,车载电脑)
- 隐式意图启动Activity,需要为intent设置以上三个属性,且值必须与该Activity在清单文件中对三个属性的定义匹配
- intent-filter节点及其子节点都可以同时定义多个,隐式启动时只需与任意一个匹配即可
获取通过setData传递的数据(掌握)
//获取启动此Activity的intent对象
Intent intent = getIntent();
Uri uri = intent.getData();
显式意图和隐式意图的应用场景(掌握)
- 显式意图用于启动同一应用中的Activity
- 隐式意图用于启动不同应用中的Activity
- 如果系统中存在多个Activity的intent-filter同时与你的intent匹配,那么系统会显示一个对话框,列出所有匹配的Activity,由用户选择启动哪一个
Activity跳转时的数据传递(掌握)
Activity通过Intent启动时,可以通过Intent对象携带数据到目标Activity
Intent intent = new Intent(this, SecondActivity.class); intent.putExtra("maleName", maleName); intent.putExtra("femaleName", femaleName); startActivity(intent);
在目标Activity中取出数据
Intent intent = getIntent(); String maleName = intent.getStringExtra("maleName"); String femaleName = intent.getStringExtra("femaleName");
Activity生命周期(掌握)
void onCreate()
- Activity已经被创建完毕
void onStart()
- Activity已经显示在屏幕,但没有得到焦点
void onResume()
- Activity得到焦点,可以与用户交互
void onPause()
- Activity失去焦点,无法再与用户交互,但依然可见
void onStop()
- Activity不可见,进入后台
void onDestroy()
- Activity被销毁
void onRestart()
- Activity从不可见变成可见时会执行此方法
使用场景
- Activity创建时需要初始化资源,销毁时需要释放资源;或者播放器应用,在界面进入后台时需要自动暂停
完整生命周期(entire lifetime)
onCreate–>onStart–>onResume–>onPause–>onStop–>onDestory
可视生命周期(visible lifetime)
onStart–>onResume–>onPause–>onStop
前台生命周期(foreground lifetime)
onResume–>onPause
Activity的四种启动模式(掌握)
每个应用会有一个Activity任务栈,存放已启动的Activity
Activity的启动模式,修改任务栈的排列情况
- standard 标准启动模式
- singleTop 单一顶部模式
- 如果任务栈的栈顶存在这个要开启的activity,不会重新的创建activity,而是复用已经存在的activity。保证栈顶如果存在,不会重复创建。
- 应用场景:浏览器的书签
singeTask 单一任务栈,在当前任务栈里面只能有一个实例存在
- 当开启activity的时候,就去检查在任务栈里面是否有实例已经存在,如果有实例存在就复用这个已经存在的activity,并且把这个activity上面的所有的别的activity都清空,复用这个已经存在的activity。保证整个任务栈里面只有一个实例存在
- 应用场景:浏览器的activity
- 如果一个activity的创建需要占用大量的系统资源(cpu,内存)一般配置这个activity为singletask的启动模式。webkit内核 c代码
singleInstance启动模式非常特殊, activity会运行在自己的任务栈里面,并且这个任务栈里面只有一个实例存在
- 如果你要保证一个activity在整个手机操作系统里面只有一个实例存在,使用singleInstance
- 应用场景: 电话拨打界面
横竖屏切换的生命周期(熟悉)
默认情况下 ,横竖屏切换, 销毁当前的activity,重新创建一个新的activity
快捷键ctrl+F11
在一些特殊的应用程序常见下,比如游戏,不希望横竖屏切换activity被销毁重新创建
需求:禁用掉横竖屏切换的生命周期
横竖屏写死
android:screenOrientation=”landscape”
android:screenOrientation=”portrait”让系统的环境 不再去敏感横竖屏的切换。
android:configChanges="orientation|screenSize|keyboardHidden"
掌握开启activity获取返回值(掌握)
从A界面打开B界面, B界面关闭的时候,返回一个数据给A界面
步骤:
开启activity并且获取返回值
startActivityForResult(intent, 0);
在新开启的界面里面实现设置数据的逻辑
Intent data = new Intent(); data.putExtra("phone", phone); //设置一个结果数据,数据会返回给调用者 setResult(0, data); finish();//关闭掉当前的activity,才会返回数据
在开启者activity里面实现方法
//通过data获取返回的数据 onActivityResult(int requestCode, int resultCode, Intent data) { }
- 通过判断请求码和结果码确定返回值的作用
广播(掌握)
- 广播的概念
- 现实:电台通过发送广播发布消息,买个收音机,就能收听
- Android:系统在产生某个事件时发送广播,应用程序使用广播接收者接收这个广播,就知道系统产生了什么事件。
Android系统在运行的过程中,会产生很多事件,比如开机、电量改变、收发短信、拨打电话、屏幕解锁
广播接收者(掌握)
- 当一条广播被发送出来时,系统是在所有清单文件中遍历,通过匹配意图过滤器找到能接收这条广播的广播接收者
IP拨号器(掌握)
原理:接收拨打电话的广播,修改广播内携带的电话号码
* 定义广播接收者接收打电话广播
public class CallReceiver extends BroadcastReceiver {
//当广播接收者接收到广播时,此方法会调用
@Override
public void onReceive(Context context, Intent intent) {
//拿到用户拨打的号码
String number = getResultData();
//修改广播内的号码
setResultData("17951" + number);
}
}
* 在清单文件中定义该广播接收者接收的广播类型
<receiver android:name="com.itheima.ipdialer.CallReceiver">
<intent-filter >
<action android:name="android.intent.action.NEW_OUTGOING_CALL"/>
</intent-filter>
</receiver>
* 接收打电话广播需要权限
<uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS"/>
* 即使广播接收者的进程没有启动,当系统发送的广播可以被该接收者接收时,系统会自动启动该接收者所在的进程
短信拦截器(熟悉)
系统收到短信时会产生一条广播,广播中包含了短信的号码和内容
定义广播接收者接收短信广播
public void onReceive(Context context, Intent intent) { //拿到广播里携带的短信内容 Bundle bundle = intent.getExtras(); Object[] objects = (Object[]) bundle.get("pdus"); for(Object ob : objects ){ //通过object对象创建一个短信对象 SmsMessage sms = SmsMessage.createFromPdu((byte[])ob); System.out.println(sms.getMessageBody()); System.out.println(sms.getOriginatingAddress()); }
}
- 系统创建广播时,把短信存放到一个数组,然后把数据以pdus为key存入bundle,再把bundle存入intent
清单文件中配置广播接收者接收的广播类型,注意要设置优先级属性,要保证优先级高于短信应用,才可以实现拦截
<receiver android:name="com.itheima.smslistener.SmsReceiver"> <intent-filter android:priority="1000"> <action android:name="android.provider.Telephony.SMS_RECEIVED"/> </intent-filter> </receiver>
添加权限
<uses-permission android:name="android.permission.RECEIVE_SMS"/>
4.0之后,广播接收者所在的应用必须启动过一次,才能生效
- 4.0之后,如果广播接收者所在应用被用户手动关闭了,那么再也不会启动了,直到用户再次手动启动该应用
监听SD卡状态(掌握)
清单文件中定义广播接收者接收的类型,监听SD卡常见的三种状态,所以广播接收者需要接收三种广播
<receiver android:name="com.itheima.sdcradlistener.SDCardReceiver"> <intent-filter > <action android:name="android.intent.action.MEDIA_MOUNTED"/> <action android:name="android.intent.action.MEDIA_UNMOUNTED"/> <action android:name="android.intent.action.MEDIA_REMOVED"/> <data android:scheme="file"/> </intent-filter> </receiver>
广播接收者的定义
public class SDCardReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { // 区分接收到的是哪个广播 String action = intent.getAction(); if(action.equals("android.intent.action.MEDIA_MOUNTED")){ System.out.println("sd卡就绪"); } else if(action.equals("android.intent.action.MEDIA_UNMOUNTED")){ System.out.println("sd卡被移除"); } else if(action.equals("android.intent.action.MEDIA_REMOVED")){ System.out.println("sd卡被拔出"); } } }
勒索软件(掌握)
- 接收开机广播,在广播接收者中启动勒索的Activity
清单文件中配置接收开机广播
<receiver android:name="com.itheima.lesuo.BootReceiver"> <intent-filter > <action android:name="android.intent.action.BOOT_COMPLETED"/> </intent-filter> </receiver>
权限
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
定义广播接收者
@Override public void onReceive(Context context, Intent intent) { //开机的时候就启动勒索软件 Intent it = new Intent(context, MainActivity.class); context.startActivity(it); }
- 以上代码还不能启动MainActivity,因为广播接收者的启动,并不会创建任务栈,那么没有任务栈,就无法启动activity
手动设置创建新任务栈的flag
it.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
监听应用的安装、卸载、更新(熟悉)
原理:应用在安装卸载更新时,系统会发送广播,广播里会携带应用的包名
* 清单文件定义广播接收者接收的类型,因为要监听应用的三个动作,所以需要接收三种广播
<receiver android:name="com.itheima.app.AppReceiver">
<intent-filter >
<action android:name="android.intent.action.PACKAGE_ADDED"/>
<action android:name="android.intent.action.PACKAGE_REPLACED"/>
<action android:name="android.intent.action.PACKAGE_REMOVED"/>
<data android:scheme="package"/>
</intent-filter>
</receiver>
* 广播接收者的定义
public void onReceive(Context context, Intent intent) {
//区分接收到的是哪种广播
String action = intent.getAction();
//获取广播中包含的应用包名
Uri uri = intent.getData();
if(action.equals("android.intent.action.PACKAGE_ADDED")){
System.out.println(uri + "被安装了");
}
else if(action.equals("android.intent.action.PACKAGE_REPLACED")){
System.out.println(uri + "被更新了");
}
else if(action.equals("android.intent.action.PACKAGE_REMOVED")){
System.out.println(uri + "被卸载了");
}
}
广播的两种类型(掌握)
- 无序广播:所有跟广播的intent匹配的广播接收者都可以收到该广播,并且是没有先后顺序(同时收到)
- 有序广播:所有跟广播的intent匹配的广播接收者都可以收到该广播,但是会按照广播接收者的优先级来决定接收的先后顺序
- 优先级的定义:-1000~1000
- 结果接收者:所有广播接收者都接收到广播之后,它才接收,并且一定会接收
- abortBroadCast:阻止其他接收者接收这条广播,类似拦截,只有有序广播可以被拦截
Service(掌握)
- 就是默默运行在后台的组件,可以理解为是没有前台的activity,适合用来运行不需要前台界面的代码
- 服务可以被手动关闭,不会重启,但是如果被自动关闭,内存充足就会重启
- startService启动服务的生命周期
- onCreate-onStartCommand-onDestroy
- 重复的调用startService会导致onStartCommand被重复调用
进程优先级(掌握)
- 前台进程:拥有一个正在与用户交互的activity(onResume方法被调用)的进程
- 可见进程:拥有一个非前台,但是对用户可见的activity(onPause方法被调用)的进程
- 服务进程:拥有一个通过startService方法启动的服务的进程
- 后台进程:拥有一个后台activity(onStop方法被调用)的进程
- 空进程:没有拥有任何活动的应用组件的进程,也就是没有任何服务和activity在运行
电话窃听器(熟悉)
- 电话状态:空闲、响铃、接听
获取电话管理器,设置侦听
TelephonyManager tm = (TelephonyManager) getSystemService(TELEPHONY_SERVICE); tm.listen(new MyPhoneStateListener(), PhoneStateListener.LISTEN_CALL_STATE);
侦听对象的实现
class MyPhoneStateListener extends PhoneStateListener{ //当电话状态改变时,此方法调用 @Override public void onCallStateChanged(int state, String incomingNumber) { // TODO Auto-generated method stub super.onCallStateChanged(state, incomingNumber); switch (state) { case TelephonyManager.CALL_STATE_IDLE://空闲 if(recorder != null){ recorder.stop(); recorder.release(); } break; case TelephonyManager.CALL_STATE_OFFHOOK://摘机 if(recorder != null){ recorder.start(); } break; case TelephonyManager.CALL_STATE_RINGING://响铃 recorder = new MediaRecorder(); //设置声音来源 recorder.setAudioSource(MediaRecorder.AudioSource.MIC); //设置音频文件格式 recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); recorder.setOutputFile("sdcard/haha.3gp"); //设置音频文件编码 recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB); try { recorder.prepare(); } catch (IllegalStateException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } break; } } }
服务两种启动方式(掌握)
- startService
- 开始服务,会使进程变成为服务进程
- 启动服务的activity和服务不再有一毛钱关系
- bindService
- 绑定服务不会使进程变成服务进程
- 绑定服务,是activity与服务建立连接,如果activity销毁了,服务也会被解绑并销毁,但是如果服务被销毁,activity不会被销毁
- 绑定服务和解绑服务的生命周期方法:onCreate->onBind->onUnbind->onDestroy
找领导办证(掌握)
- 把服务看成一个领导,服务中有一个banZheng方法,如何才能访问?
- 绑定服务时,会触发服务的onBind方法,此方法会返回一个Ibinder的对象给MainActivity,通过这个对象访问服务中的方法
绑定服务
Intent intent = new Intent(this, BanZhengService.class); bindService(intent, conn, BIND_AUTO_CREATE);
- 绑定服务时要求传入一个ServiceConnection实现类的对象
定义这个实现类
class MyServiceconn implements ServiceConnection{ @Override public void onServiceConnected(ComponentName name, IBinder service) { zjr = (PublicBusiness) service; } @Override public void onServiceDisconnected(ComponentName name) { }
}
创建实现类对象
conn = new MyServiceconn();
在服务中定义一个类实现Ibinder接口,以在onBind方法中返回
class ZhongJianRen extends Binder implements PublicBusiness{ public void QianXian(){ //访问服务中的banZheng方法 BanZheng(); } public void daMaJiang(){ }
}
- 把QianXian方法抽取到接口PublicBusiness中定义
两种启动方法混合使用(掌握)
- 用服务实现音乐播放时,因为音乐播放必须运行在服务进程中,可是音乐服务中的方法,需要被前台Activity所调用,所以需要混合启动音乐服务
- 先start,再bind,销毁时先unbind,在stop
使用服务注册广播接收者(掌握)
- Android四大组件都要在清单文件中注册
- 广播接收者可以使用清单文件注册
- 一旦应用部署,广播接收者就生效了,直到用户手动停止应用或者应用被删除
- 广播接收者可以使用代码注册
- 需要广播接收者运行时,使用代码注册,不需要时,可以使用代码解除注册
电量改变、屏幕开关,必须使用代码注册
注册广播接收者
//创建广播接收者对象 receiver = new ScreenOnOffReceiver(); //通过IntentFilter对象指定广播接收者接收什么类型的广播 IntentFilter filter = new IntentFilter(); filter.addAction(Intent.ACTION_SCREEN_OFF); filter.addAction(Intent.ACTION_SCREEN_ON); //注册广播接收者 registerReceiver(receiver, filter);
解除注册广播接收者
unregisterReceiver(receiver);
- 解除注册之后,广播接收者将失去作用
本地服务:服务和启动它的组件在同一个进程
远程服务:服务和启动它的组件不在同一个进程
- 远程服务只能隐式启动,类似隐式启动Activity,在清单文件中配置Service标签时,必须配置intent-filter子节点,并指定action子节点
AIDL(掌握)
- Android interface definition language
- 安卓接口定义语言
- 作用:跨进程通信
- 应用场景:远程服务中的中间人对象,其他应用是拿不到的,那么在通过绑定服务获取中间人对象时,就无法强制转换,使用aidl,就可以在其他应用中拿到中间人类所实现的接口
支付宝远程服务
- 定义支付宝的服务,在服务中定义pay方法
- 定义中间人对象,把pay方法抽取成接口
- 把抽取出来的接口后缀名改成aidl
- 中间人对象直接继承Stub对象
- 注册这个支付宝服务,定义它的intent-Filter
需要支付的应用
- 把刚才定义好的aidl文件拷贝过来,注意aidl文件所在的包名必须跟原包名一致
- 远程绑定支付宝的服务,通过onServiceConnected方法我们可以拿到中间人对象
- 把中间人对象通过Stub.asInterface方法强转成定义了pay方法的接口
- 调用中间人的pay方法
五种前台进程(掌握)
- activity执行了onresume方法,获得焦点
- 拥有一个跟正在与用户交互的activity绑定的服务
- 拥有一个服务执行了startForeground()方法
- 拥有一个正在执行onCreate()、onStart()或者onDestroy()方法中的任意一个的服务
- 拥有一个正在执行onReceive方法的广播接收者
两种可见进程(掌握)
- activity执行了onPause方法,失去焦点,但是可见
- 拥有一个跟可见或前台activity绑定的服务
对话框
确定取消对话框(掌握)
- 创建对话框构建器对象,类似工厂模式
-
AlertDialog.Builder builder = new Builder(this); - 设置标题和正文
-
builder.setTitle(“警告”);
builder.setMessage(“若练此功,必先自宫”); 设置确定和取消按钮
builder.setPositiveButton("现在自宫", new OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { // TODO Auto-generated method stub Toast.makeText(MainActivity.this, "恭喜你自宫成功,现在程序退出", 0).show(); } }); builder.setNegativeButton("下次再说", new OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { // TODO Auto-generated method stub Toast.makeText(MainActivity.this, "若不自宫,一定不成功", 0).show(); } });
使用构建器创建出对话框对象
AlertDialog ad = builder.create(); ad.show();
单选对话框(熟悉)
AlertDialog.Builder builder = new Builder(this);
builder.setTitle("选择你的性别");
* 定义单选选项
*
final String[] items = new String[]{
“男”, “女”, “其他”
};
//-1表示没有默认选择
//点击侦听的导包要注意别导错
builder.setSingleChoiceItems(items, -1, new OnClickListener() {
//which表示点击的是哪一个选项
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(MainActivity.this, "您选择了" + items[which], 0).show();
//对话框消失
dialog.dismiss();
}
});
builder.show();
多选对话框(熟悉)
AlertDialog.Builder builder = new Builder(this);
builder.setTitle("请选择你认为最帅的人");
* 定义多选的选项,因为可以多选,所以需要一个boolean数组来记录哪些选项被选了
*
final String[] items = new String[]{
“赵帅哥”,
“赵师哥”,
“赵老师”,
“侃哥”
};
//true表示对应位置的选项被选了
final boolean[] checkedItems = new boolean[]{
true,
false,
false,
false,
};
builder.setMultiChoiceItems(items, checkedItems, new OnMultiChoiceClickListener() {
//点击某个选项,如果该选项之前没被选择,那么此时isChecked的值为true
@Override
public void onClick(DialogInterface dialog, int which, boolean isChecked) {
checkedItems[which] = isChecked;
}
});
builder.setPositiveButton("确定", new OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
StringBuffer sb = new StringBuffer();
for(int i = 0;i < items.length; i++){
sb.append(checkedItems[i] ? items[i] + " " : "");
}
Toast.makeText(MainActivity.this, sb.toString(), 0).show();
}
});
builder.show();
国际化(掌握)
样式与主题(熟悉)
- 样式与主题定义方式一样
- 样式用于布局文件中的组件
- 主题用于Activity
多媒体概念(了解)
- 文字、图片、音频、视频
计算机图片大小的计算(掌握)
图片大小 = 图片的总像素 * 每个像素占用的大小
- 单色图:每个像素占用1/8个字节
- 16色图:每个像素占用1/2个字节
- 256色图:每个像素占用1个字节
- 24位图:每个像素占用3个字节
加载大图片到内存(掌握)
Android系统以ARGB表示每个像素,所以每个像素占用4个字节,很容易内存溢出
对图片进行缩放(掌握)
获取屏幕宽高
Display dp = getWindowManager().getDefaultDisplay();
int screenWidth = dp.getWidth();
int screenHeight = dp.getHeight();获取图片宽高
Options opts = new Options(); //请求图片属性但不申请内存 opts.inJustDecodeBounds = true; BitmapFactory.decodeFile("sdcard/dog.jpg", opts); int imageWidth = opts.outWidth; int imageHeight = opts.outHeight;
图片的宽高除以屏幕宽高,算出宽和高的缩放比例,取较大值作为图片的缩放比例
int scale = 1; int scaleX = imageWidth / screenWidth; int scaleY = imageHeight / screenHeight; if(scaleX >= scaleY && scaleX > 1){ scale = scaleX; } else if(scaleY > scaleX && scaleY > 1){ scale = scaleY; }
按缩放比例加载图片
//设置缩放比例 opts.inSampleSize = scale; //为图片申请内存 opts.inJustDecodeBounds = false; Bitmap bm = BitmapFactory.decodeFile("sdcard/dog.jpg", opts); iv.setImageBitmap(bm);
在内存中创建图片的副本(掌握)
直接加载的bitmap对象是只读的,无法修改,要修改图片只能在内存中创建出一个一模一样的bitmap副本,然后修改副本
//加载原图
Bitmap srcBm = BitmapFactory.decodeFile("sdcard/photo3.jpg");
iv_src.setImageBitmap(srcBm);
//创建与原图大小一致的空白bitmap
Bitmap copyBm = Bitmap.createBitmap(srcBm.getWidth(), srcBm.getHeight(), srcBm.getConfig());
//定义画笔
Paint paint = new Paint();
//把纸铺在画版上
Canvas canvas = new Canvas(copyBm);
//把srcBm的内容绘制在copyBm上
canvas.drawBitmap(srcBm, new Matrix(), paint);
iv_copy.setImageBitmap(copyBm);
对图片进行特效处理(熟悉)
首先定义一个矩阵对象
Matrix mt = new Matrix();
缩放效果
//x轴缩放1倍,y轴缩放0.5倍 mt.setScale(1, 0.5f);
旋转效果
//以copyBm.getWidth() / 2, copyBm.getHeight() / 2点为轴点,顺时旋转30度 mt.setRotate(30, copyBm.getWidth() / 2, copyBm.getHeight() / 2);
平移
//x轴坐标+10,y轴坐标+20 mt.setTranslate(10, 20);
镜面
//把X坐标都变成负数 mt.setScale(-1, 1); //图片整体向右移(要用post,不能用setTranslate,set会复位) mt.postTranslate(copyBm.getWidth(), 0);
倒影
//把Y坐标都变成负数 mt.setScale(1, -1); //图片整体向下移 mt.postTranslate(0, copyBm.getHeight());
画画板(掌握)
记录用户触摸事件的XY坐标,绘制直线
* 给ImageView设置触摸侦听,得到用户的触摸事件,并获知用户触摸ImageView的坐标
iv.setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
// TODO Auto-generated method stub
switch (event.getAction()) {
//触摸屏幕
case MotionEvent.ACTION_DOWN:
//得到触摸屏幕时手指的坐标
startX = (int) event.getX();
startY = (int) event.getY();
break;
//在屏幕上滑动
case MotionEvent.ACTION_MOVE:
//用户滑动手指,坐标不断的改变,获取最新坐标
int newX = (int) event.getX();
int newY = (int) event.getY();
//用上次onTouch方法得到的坐标和本次得到的坐标绘制直线
canvas.drawLine(startX, startY, newX, newY, paint);
iv.setImageBitmap(copyBm);
startX = newX;
startY = newY;
break;
}
return true;
}
});
* 刷子效果,加粗画笔
paint.setStrokeWidth(8);
* 调色板,改变画笔颜色
paint.setColor(Color.GREEN);
* 保存图片至SD卡
FileOutputStream fos = null;
try {
fos = new FileOutputStream(new File("sdcard/dazuo.png"));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//保存图片
copyBm.compress(CompressFormat.PNG, 100, fos);
* 系统每次收到SD卡就绪广播时,都会去遍历sd卡的所有文件和文件夹,把遍历到的所有多媒体文件都在MediaStore数据库保存一个索引,这个索引包含多媒体文件的文件名、路径、大小
* 图库每次打开时,并不会去遍历sd卡获取图片,而是通过内容提供者从MediaStore数据库中获取图片的信息,然后读取该图片
* 系统开机或者点击加载sd卡按钮时,系统会发送sd卡就绪广播,我们也可以手动发送就绪广播
Intent intent = new Intent();
intent.setAction(Intent.ACTION_MEDIA_MOUNTED);
intent.setData(Uri.fromFile(Environment.getExternalStorageDirectory()));
sendBroadcast(intent);
撕衣服(掌握)
原理:把穿内衣和穿外衣的照片重叠显示,内衣照在下面,用户滑动屏幕时,触摸的是外衣照,把手指经过的像素都置为透明,内衣照就显示出来了
iv.setOnTouchListener(new OnTouchListener() { @Override public boolean onTouch(View v, MotionEvent event) { switch (event.getAction()) { case MotionEvent.ACTION_MOVE: int newX = (int) event.getX(); int newY = (int) event.getY(); //把指定的像素变成透明 copyBm.setPixel(newX, newY, Color.TRANSPARENT); iv.setImageBitmap(copyBm); break; } return true; } });
每次只设置一个像素点太慢,以触摸的像素为圆心,半径为5画圆,圆内的像素全部置为透明
for (int i = -5; i < 6; i++) { for (int j = -5; j < 6; j++) { if(Math.sqrt(i * i + j * j) <= 5) copyBm.setPixel(newX + i, newY + j, Color.TRANSPARENT); } }
音乐播放器
播放服务(掌握)
- 播放音频的代码应该运行在服务中,定义一个播放服务MusicService
服务里定义play、stop、pause、continuePlay等方法
private void play() { // TODO Auto-generated method stub player.reset(); try { player.setDataSource("sdcard/bzj.mp3"); player.prepare(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } player.start(); } private void pause() { player.pause(); } private void stop() { player.stop(); } private void continuePlay() { player.start(); }
- 把这几个方法抽取成一个接口MusicInterface
- 定义一个中间人类,继承Binder,实现MusicInterface
先start启动MusicService,再bind
Intent intent = new Intent(this, MusicService.class); startService(intent); bindService(intent, conn, BIND_AUTO_CREATE);
根据播放进度设置进度条(掌握)
获取当前的播放时间和当前音频的最长时间
int currentPosition = player.getCurrentPosition(); int duration = player.getDuration();
- 播放进度需要不停的获取,不停的刷新进度条,使用计时器每500毫秒获取一次播放进度
发消息至Handler,把播放进度放进Message对象中,在Handler中更新SeekBar的进度
Timer timer = new Timer(); timer.schedule(new TimerTask() { @Override public void run() { int currentPosition = player.getCurrentPosition(); int duration = player.getDuration(); Message msg = Message.obtain(); //把播放进度存入Message中 Bundle data = new Bundle(); data.putInt("currentPosition", currentPosition); data.putInt("duration", duration); msg.setData(data); MainActivity.handler.sendMessage(msg); } }, 5, 500);
在Activity中定义Handler
static Handler handler = new Handler(){ public void handleMessage(android.os.Message msg) { //取出消息携带的数据 Bundle data = msg.getData(); int currentPosition = data.getInt("currentPosition"); int duration = data.getInt("duration"); //设置播放进度 sb.setMax(duration); sb.setProgress(currentPosition); }; };
拖动进度条改变播放进度
//给sb设置一个拖动侦听
sb.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
//停止拖动时调用
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
// TODO Auto-generated method stub
int progress = seekBar.getProgress();
mi.seekTo(progress);
}
//开始拖动时调用
@Override
public void onStartTrackingTouch(SeekBar seekBar) {
// TODO Auto-generated method stub
}
//拖动的时候不断调用
@Override
public void onProgressChanged(SeekBar seekBar, int progress,
boolean fromUser) {
// TODO Auto-generated method stub
}
});
视频播放器(熟悉)
SurfaceView
- 对画面的实时更新要求较高
- 双缓冲技术:内存中有两个画布,A画布显示至屏幕,B画布在内存中绘制下一帧画面,绘制完毕后B显示至屏幕,A在内存中继续绘制下一帧画面
播放视频也是用MediaPlayer,不过跟音频不同,要设置显示在哪个SurfaceView
SurfaceView sv = (SurfaceView) findViewById(R.id.sv); SurfaceHolder sh = sv.getHolder(); MediaPlayer player = new MediaPlayer(); player.reset(); try { player.setDataSource("sdcard/2.3gp"); player.setDisplay(sh); player.prepare(); } catch (Exception e) { e.printStackTrace(); } player.start();
- SurfaceView是重量级组件,可见时才会创建
给SurfaceHolder设置CallBack,类似于侦听,可以知道SurfaceView的状态
sh.addCallback(new Callback() { //SurfaceView销毁时调用 @Override public void surfaceDestroyed(SurfaceHolder holder) { // TODO Auto-generated method stub } //SurfaceView创建时调用 @Override public void surfaceCreated(SurfaceHolder holder) { // TODO Auto-generated method stub } @Override public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { // TODO Auto-generated method stub } });
- SurfaceView一旦不可见,就会被销毁,一旦可见,就会被创建,销毁时停止播放,再次创建时再开始播放
摄像头(熟悉)
启动系统提供的拍照程序
//隐式启动系统提供的拍照Activity Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); //设置照片的保存路径 File file = new File(Environment.getExternalStorageDirectory(), "haha.jpg"); intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file)); startActivityForResult(intent, 0);
启动系统提供的摄像程序
Intent intent = new Intent(MediaStore.ACTION_VIDEO_CAPTURE); File file = new File(Environment.getExternalStorageDirectory(), "haha.3gp"); intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file)); //设置保存视频文件的质量 intent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 1); startActivityForResult(intent, 0);
使用Camera类完成照相(熟悉)
- 查阅文档
内容提供者(掌握)
- 应用的数据库是不允许其他应用访问的
- 内容提供者的作用就是让别的应用访问到你的私有数据
自定义内容提供者,继承ContentProvider类,重写增删改查方法,在方法中写增删改查数据库的代码,举例增方法
@Override public Uri insert(Uri uri, ContentValues values) { db.insert("person", null, values); return uri; }
在清单文件中定义内容提供者的标签,注意必须要有authorities属性,这是内容提供者的主机名,功能类似地址
<provider android:name="com.itheima.contentprovider.PersonProvider" android:authorities="com.itheima.person" android:exported="true" ></provider>
创建一个其他应用,访问自定义的内容提供者,实现对数据库的插入操作
public void click(View v){ //得到内容分解器对象 ContentResolver cr = getContentResolver(); ContentValues cv = new ContentValues(); cv.put("name", "小方"); cv.put("phone", 138856); cv.put("money", 3000); //url:内容提供者的主机名 cr.insert(Uri.parse("content://com.itheima.person"), cv); }
UriMatcher(掌握)
- 用于判断一条uri跟指定的多条uri中的哪条匹配
添加匹配规则
//指定多条uri um.addURI("com.itheima.person", "person", PERSON_CODE); um.addURI("com.itheima.person", "company", COMPANY_CODE); //#号可以代表任意数字 um.addURI("com.itheima.person", "person/#", QUERY_ONE_PERSON_CODE);
通过Uri匹配器可以实现操作不同的表
@Override public Uri insert(Uri uri, ContentValues values) { if(um.match(uri) == PERSON_CODE){ db.insert("person", null, values); } else if(um.match(uri) == COMPANY_CODE){ db.insert("company", null, values); } else{ throw new IllegalArgumentException(); } return uri; }
如果路径中带有数字,把数字提取出来的api
int id = (int) ContentUris.parseId(uri);
短信数据库(掌握)
- 只需要关注sms表
- 只需要关注4个字段
- body:短信内容
- address:短信的发件人或收件人号码(跟你聊天那哥们的号码)
- date:短信时间
- type:1为收到,2为发送
读取系统短信,首先查询源码获得短信数据库内容提供者的主机名和路径,然后访问内容提供者(掌握)
ContentResolver cr = getContentResolver();
Cursor c = cr.query(Uri.parse("content://sms"), new String[]{"body", "date", "address", "type"}, null, null, null);
while(c.moveToNext()){
String body = c.getString(0);
String date = c.getString(1);
String address = c.getString(2);
String type = c.getString(3);
System.out.println(body+";" + date + ";" + address + ";" + type);
}
插入系统短信(熟悉)
ContentResolver cr = getContentResolver();
ContentValues cv = new ContentValues();
cv.put("body", "您尾号为XXXX的招行储蓄卡收到转账1,000,000人民币");
cv.put("address", 95555);
cv.put("type", 1);
cv.put("date", System.currentTimeMillis());
cr.insert(Uri.parse("content://sms"), cv);
* 插入查询系统短信需要注册权限
联系人数据库(掌握)
- raw_contacts表:
- contact_id:联系人id
- data表:联系人的具体信息,一个信息占一行
- data1:信息的具体内容
- raw_contact_id:联系人id,描述信息属于哪个联系人
- mimetype_id:描述信息是属于什么类型
- mimetypes表:通过mimetype_id到该表查看具体类型
读取联系人(掌握)
先查询raw_contacts表拿到联系人id
Cursor cursor = cr.query(Uri.parse("content://com.android.contacts/raw_contacts"), new String[]{"contact_id"}, null, null, null);
然后拿着联系人id去data表查询属于该联系人的信息
Cursor c = cr.query(Uri.parse("content://com.android.contacts/data"), new String[]{"data1", "mimetype"}, "raw_contact_id = ?", new String[]{contactId}, null);
得到data1字段的值,就是联系人的信息,通过mimetype判断是什么类型的信息
while(c.moveToNext()){ String data1 = c.getString(0); String mimetype = c.getString(1); if("vnd.android.cursor.item/email_v2".equals(mimetype)){ contact.setEmail(data1); } else if("vnd.android.cursor.item/name".equals(mimetype)){ contact.setName(data1); } else if("vnd.android.cursor.item/phone_v2".equals(mimetype)){ contact.setPhone(data1); } }
插入联系人(熟悉)
- 先查询raw_contacts表,确定新的联系人的id应该是多少
把确定的联系人id插入raw_contacts表
cv.put("contact_id", _id); cr.insert(Uri.parse("content://com.android.contacts/raw_contacts"), cv);
在data表插入数据
插3个字段:data1、mimetype、raw_contact_id
cv = new ContentValues(); cv.put("data1", "赵六"); cv.put("mimetype", "vnd.android.cursor.item/name"); cv.put("raw_contact_id", _id); cr.insert(Uri.parse("content://com.android.contacts/data"), cv); cv = new ContentValues(); cv.put("data1", "1596874"); cv.put("mimetype", "vnd.android.cursor.item/phone_v2"); cv.put("raw_contact_id", _id); cr.insert(Uri.parse("content://com.android.contacts/data"), cv);
内容观察者(掌握)
当数据库数据改变时,内容提供者会发出通知,在内容提供者的uri上注册一个内容观察者,就可以收到数据改变的通知
cr.registerContentObserver(Uri.parse("content://sms"), true, new MyObserver(new Handler())); class MyObserver extends ContentObserver{ public MyObserver(Handler handler) { super(handler); // TODO Auto-generated constructor stub } //内容观察者收到数据库发生改变的通知时,会调用此方法 @Override public void onChange(boolean selfChange) { } }
在内容提供者中发通知的代码
ContentResolver cr = getContext().getContentResolver(); //发出通知,所有注册在这个uri上的内容观察者都可以收到通知 cr.notifyChange(uri, null);
Fragment(重要)
- 用途:在一个Activity里切换界面,切换界面时只切换Fragment里面的内容
- 生命周期方法跟Activity一致,可以理解把其为就是一个Activity
- fragment切换时会销毁旧的,再创建新的
定义布局文件作为Fragment的显示内容
//此方法返回的View就会被显示在Fragment上 @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { // TODO Auto-generated method stub //用布局文件填充成一个View对象,返回出去,那么就显示在Fragment上了 View v = inflater.inflate(R.layout.fragment01, null); return v; }
把Fragment显示至指定ViewGroup中
//把fragment显示至界面 //new出fragment对象 Fragment01 fg = new Fragment01(); FragmentManager fm = getFragmentManager(); //开启事务 FragmentTransaction ft = fm.beginTransaction(); //把fragment对象显示到指定资源id的组件里面 ft.replace(R.id.fl, fg); ft.commit();
生命周期(重要)
- fragment切换时旧fragment对象会销毁,新的fragment对象会被创建
低版本兼容(熟悉)
- 在support-v4.jar包中有相关api,也就是说fragment可以在低版本模拟器运行
动画(重要)
帧动画(重要)
一张张图片不断的切换,形成动画效果
在drawable目录下定义xml文件,子节点为animation-list,在这里定义要显示的图片和每张图片的显示时长
<animation-list xmlns:android="http://schemas.android.com/apk/res/android" android:oneshot="false"> <item android:drawable="@drawable/g1" android:duration="200" /> <item android:drawable="@drawable/g2" android:duration="200" /> <item android:drawable="@drawable/g3" android:duration="200" /> </animation-list>
在屏幕上播放帧动画
ImageView iv = (ImageView) findViewById(R.id.iv); //把动画文件设置为imageView的背景 iv.setBackgroundResource(R.drawable.animations); AnimationDrawable ad = (AnimationDrawable) iv.getBackground(); //播放动画 ad.start();
补间动画(重要)
- 原形态变成新形态时为了过渡变形过程,生成的动画就叫补间动画
- 位移、旋转、缩放、透明
位移:
- 参数10指的是X的起点坐标,但不是指屏幕x坐标为10的位置,而是imageview的 真实X + 10
参数150指的是X的终点坐标,它的值是imageview的 真实X + 150
//创建为位移动画对象,设置动画的初始位置和结束位置 TranslateAnimation ta = new TranslateAnimation(10, 150, 20, 140);
- x坐标的起点位置,如果相对于自己,传0.5f,那么起点坐标就是 真实X + 0.5 * iv宽度
- x坐标的终点位置,如果传入2,那么终点坐标就是 真实X + 2 * iv的宽度
- y坐标的起点位置,如果传入0.5f,那么起点坐标就是 真实Y + 0.5 * iv高度
y坐标的终点位置,如果传入2,那么终点坐标就是 真实Y + 2 * iv高度
TranslateAnimation ta = new TranslateAnimation(Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 2, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 2);
动画播放相关的设置
//设置动画持续时间 ta.setDuration(2000); //动画重复播放的次数 ta.setRepeatCount(1); //动画重复播放的模式 ta.setRepeatMode(Animation.REVERSE); //动画播放完毕后,组件停留在动画结束的位置上 ta.setFillAfter(true); //播放动画 iv.startAnimation(ta);
缩放:
- 参数0.1f表示动画的起始宽度是真实宽度的0.1倍
- 参数4表示动画的结束宽度是真实宽度的4倍
缩放的中心点在iv左上角
ScaleAnimation sa = new ScaleAnimation(0.1f, 4, 0.1f, 4);
- 参数0.1f和4意义与上面相同
- 改变缩放的中心点:传入的两个0.5f,类型都是相对于自己,这两个参数改变了缩放的中心点
- 中心点x坐标 = 真实X + 0.5 * iv宽度
中心点Y坐标 = 真实Y + 0.5 * iv高度
ScaleAnimation sa = new ScaleAnimation(0.1f, 4, 0.1f, 4, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
透明:
0为完全透明,1为完全不透明
AlphaAnimation aa = new AlphaAnimation(0, 0.5f);
旋转:
- 20表示动画开始时的iv的角度
- 360表示动画结束时iv的角度
默认旋转的圆心在iv左上角
RotateAnimation ra = new RotateAnimation(20, 360);
- 20,360的意义和上面一样
- 指定圆心坐标,相对于自己,值传入0.5,那么圆心的x坐标:真实X + iv宽度 * 0.5
圆心的Y坐标:真实Y + iv高度 * 0.5
RotateAnimation ra = new RotateAnimation(20, 360, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
所有动画一起飞
//创建动画集合
AnimationSet set = new AnimationSet(false);
//往集合中添加动画
set.addAnimation(aa);
set.addAnimation(sa);
set.addAnimation(ra);
iv.startAnimation(set);
属性动画(重要)
- 补间动画,只是一个动画效果,组件其实还在原来的位置上,xy没有改变
位移:
- 第一个参数target指定要显示动画的组件
- 第二个参数propertyName指定要改变组件的哪个属性
- 第三个参数values是可变参数,就是赋予属性的新的值
- 传入0,代表x起始坐标:当前x + 0
传入100,代表x终点坐标:当前x + 100
//具有get、set方法的成员变量就称为属性 ObjectAnimator oa = ObjectAnimator.ofFloat(bt, "translationX", 0, 100) ;
缩放:
- 第三个参数指定缩放的比例
- 0.1是从原本高度的十分之一开始
2是到原本高度的2倍结束
ObjectAnimator oa = ObjectAnimator.ofFloat(bt, "scaleY", 0.1f, 2);
透明:
透明度,0是完全透明,1是完全不透明
ObjectAnimator oa = ObjectAnimator.ofFloat(bt, "alpha", 0.1f, 1);
旋转
- rotation指定是顺时针旋转
- 20是起始角度
270是结束角度
ObjectAnimator oa = ObjectAnimator.ofFloat(bt, "rotation", 20, 270);
- 属性指定为rotationX是竖直翻转
属性指定为rotationY是水平翻转
ObjectAnimator oa = ObjectAnimator.ofFloat(bt, "rotationY", 20, 180);
可变参数
第三个参数可变参数可以传入多个参数,可以实现往回位移(旋转、缩放、透明)
ObjectAnimator oa = ObjectAnimator.ofFloat(bt, "translationX", 0, 70, 30, 100) ;
所有动画一起飞
//创建动画师集合
AnimatorSet set = new AnimatorSet();
//设置要播放动画的组件
set.setTarget(bt);
//所有动画有先后顺序的播放
//set.playSequentially(oa, oa2, oa3, oa4);
//所有动画一起播放
set.playTogether(oa, oa2, oa3, oa4);
set.start();