#Android 基础知识点总结
----------
##1.adb - android debug bridge
-adb start-server -----开启adb服务
-adb kill-server -----停止adb服务
-adb push 本地路径 手机路径 -----将文件导入手机
-adb pull 手机路径 本地路径 -----导出
-adb logcat -----查看Log
-adb install [-r] [-s] 全路径/xxx.apk
-r 重新安装该程序，保存数据
-s 安装在SD卡内，而不是设备内部存储
-adb uninstall [-k] 全路径/xxx.apk
-k 不删除程序运行所产生的数据和缓存目录
-adb remount -----重新挂载文件系统
-adb reboot -----重启手机
-adb reboot recovery -----重启到Recovery界面
-adb reboot bootloader -----重启到bootloader界面
-adb devices -----列出所有设备名称或IP
-adb -s IP install 全路径-apk
-adb shell -----挂载到Linux空间
-netstat -ano ---查看进程 （协议 本地地址 外部地址 状态 PID）
进入Linux空间后就好玩：
ls ---查看当前路径下的文件
ls -l ---查看文件的具体信息
ps ---查看当前运行进程
netstat -ano ---查看占用端口号的进程
monkey 1000;---猴子测试 测试整个系统；1000代表数量
monkey -p 包名 数量--- 测试某个应用程序运行数量后，会不会爆
cd .. ---返回上级目录
cat xxx.xml ---查看xml文件
sqlite3 xxx.db ---进入后
.help 查看帮助
.tables 查看所有表名
.quit 退出
**可以使用sql语句操作表
##2.UI（脸蛋）
1. 四种基本布局：
#LinearLayout#---线性布局
orientation：vertical竖直， horizontal 水平
gravity：指定子布局位置
layout_gravity：指定当前控件与父布局的相对位置
layout_weight：出去已经分配的具体屏幕大小，将剩余的屏幕大小按权重分配（自己的理解）
#RelativeLayout#---相对布局
初始位置：在屏幕左上角
容易忘记：layout_above="@id/xx" 在 xx控件上
layout_below="@id/xx" 在 xx控件下
layout_toRightOf="@id/xx" 在 xx控件右边
layout_alignParentRight="true" 在父窗体右边
layout_centerInParent="true" 在父窗体正中间
#FrameLayout#---帧布局、
特点：一层层覆盖
不好玩，用来被替换的布局，当使用碎片fragment来布局UI的时候，framelayout里面存放一个fragment
#TableLayout#---表格布局
基本不用
子控件 中无法指定宽度，使用 stretchColumns="1";
合并单元格： layout_span="2";
2. 常见控件：
#TextView#
textSize
textColor #ARGB a:透明度 r：red g：green b：blue
singleLine true 单行显示
maxLines 多行显示
#Button#
四种点击事件：
第一种：通过给控件添加onclick属性,然后进到 activity中 去添加方法
添加方法时,方法的签名也是固定的.(google不推荐使用)
andorid：onclick="xxx"
public void xxx(View v){
}`
第二种：给控件添加id , 然后 在activity中拿到 控件,然后 给控件添加onclick时间的监听器
使用匿名内部类的写法:
`android:id="@+id/xxx"
xxx = (Button) findViewById(R.id.xxx);
xxx.setOnClickListener(new OnClickListener(){
public void onClick(View v){
}
});
第三种：实际上与第二种一样, 只是换成了 内部类的写法.写个类去 实现 Onclick接口
第四种：让activity类去实现 onclicklistner接口最终通过 switch...case去判断到底点击的是哪个控件.
`android:id="@+id/xxx"
xxx = (Button) findViewById(R.id.xxx);
xxx.setOnClickListener(this);
public void onClick(View v){
int id = v.getId();
switch(id){
case R.id.xxx:
break;
default:
break;
}
}
#EditText#
hint
maxLines
inputType
et_content =(EditText) findViewById(R.id.et_content);
String et_content = et_content.getText().toString.trim();
if(TextUtils.isEmpty(et_content)){
Toast.makeText("","",Toast.Length_SHORT).show();
return;
}
#imageView#
src
ImageView.setImageResource(R.drawable.xxx);
好玩的：实现图片轮播
自己见一个xml文件：
/animation-list>`
'ImageView rocketImage = (ImageView) findViewById(R.id.rocket_image);
rocketImage.setBackgroundResource(R.drawable.rocket_thrust);
rocketAnimation = (AnimationDrawable) rocketImage.getBackground()
;
rocketAnimation.start();
#RadioGroup#
eg:
android:id="@+id/rg"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
android:layout_width="0dip"
android:layout_weight="1"
android:layout_height="wrap_content"
android:text="男"
android:id="@+id/rb_male"
/>
android:layout_width="0dip"
android:layout_weight="1"
android:layout_height="wrap_content"
android:text="女"
android:id="@+id/rb_female"
/>
获取属性值：
if(rg.getCheckedRadioButtonId() == R.id.rb_male){
sex = "male";
}else{
sex = "female";
}
'
#ProgressBar#
max
progress
重要设置样式：
style="?android:attr/progressBarStyleHorizontal"
#VideoView# 播放音频视频，底层是SurfaceView 和 mediaPlayer的结合。
vv = (VideoView) findViewById(R.id.vv);
// 设置要
vv.setVideoPath("/mnt/sdcard/lala.3gp");
//mediaController --- 媒体控制器
MediaController mc = new MediaController(this);
mc.setAnchorView(vv);
vv.setMediaController(mc); // 成功的将MediaController与vv关联起来
vv.start();
#SurfaceView#
sv = (SurfaceView) findViewById(R.id.sv);
try {
mPlayer = new MediaPlayer();
mPlayer.reset();
mPlayer.setDataSource("/mnt/sdcard/lala.3gp");
mPlayer.prepare();
} catch (Exception e) {
e.printStackTrace();
}
sp = getSharedPreferences("config", 0);
// surfaceHodler --- 界面的持有器,持有者
sv.getHolder().addCallback(new Callback() {
//surface销毁了
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
System.out.println("销毁了 ");
Editor editor = sp.edit();
editor.putInt("position", mPlayer.getCurrentPosition());
editor.commit();
mPlayer.stop();
}
//surface创建了
@Override
public void surfaceCreated(SurfaceHolder holder) {
System.out.println("创建了 ");
int position = sp.getInt("position", 0);
mPlayer.setDisplay(sv.getHolder()); //显示画面，必须设置
mPlayer.start();
mPlayer.seekTo(position); // 直接跳到某个位置, 从这个位置开始播放
}
//surface变化了
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width,
int height) {
System.out.println("修改了 ");
}
});
#ScollView# 只能有一个子节点
#WebView#
webview = new WebView(this);
//设置WebView属性，能够执行Javascript脚本
webview.getSettings().setJavaScriptEnabled(true);
//加载需要显示的网页
webview.setWebViewClient(new WebViewClient());
webview.loadUrl("http://www.xxxx.com/");
//设置Web视图
setContentView(webview);
#Fragment# 碎片 类似Activity
-1. 静态添加碎片
1.自己布局一个fragment：
android:id="@+id/fm_left" //id必须写，不然会报错
android:name="com.example.fragment.LeftFragment"// 添加name属性，包名必须写，此为加载LeftFragment 类
android:layout_weight="1"
android:layout_width="0dp"
android:layout_height="match_parent"/>
2.定义一个LeftFragment 继承 Fragment
public class LeftFragment extends Fragment {
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
//false 代表 不附着在parent布局中
return inflater.inflate(R.layout.left, container,false);
}
}
3.定义一个R.layout.left布局文件
-2. 动态添加碎片
核心代码
RightFragment rightFragment = new RightFragment();
FragmentManager fragmentManager = getFragmentManager();
FragmentTransaction beginTransaction = fragmentManager.beginTransaction();
beginTransaction.replace(R.id.fl, rightFragment);
beginTransaction.commit();
3. 四种对话框（不能用Application的上下文）
-1.取消对话框
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("please "); // 下面都对话框都可以设置标题
builder.setMessage("继续撸代码吗?"); // 同上
builder.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(MainActivity.this, "lu", 0).show();
}
}); //确定按钮的点击事件
builder.setNegativeButton("No", null); //取消按钮的点击事件
builder.show();
-2.单选对话框
Builder builder = new AlertDialog.Builder(this);
final String[] items = new String[]{"male","female"};
builder.setSingleChoiceItems(items, 0, new DialogInterface.OnClickListener() {
@Override
//which 是数组的 索引，下同
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(MainActivity.this, "你选的是"+items[which], 0).show();
}
});
builder.show();
-3.多选对话框
AlertDialog.Builder builder = new AlertDialog.Builder(this);
final String[] items = new String[]{"跳楼","上吊","撸代码","滚回家"};
final boolean[] checkedItems = new boolean[]{false,false,false,false};
// fasle 代表默认不被选中
builder.setMultiChoiceItems(items, checkedItems, new DialogInterface.OnMultiChoiceClickListener() {
@Override
public void onClick(DialogInterface dialog, int which, boolean isChecked) {
Toast.makeText(MainActivity.this, "你选的是"+items[which], 0).show();
checkedItems[which] = isChecked;
}
});
builder.show();
-4.进度条对话框
final ProgressDialog progressDialog = ProgressDialog.show(MainActivity.this, "please wait", "加载loading。。。。。");
new Thread(){
public void run(){
progressDialog.setCancelable(false);//Back键不能取消掉
SystemClock.sleep(2000);
progressDialog.dismiss(); //设置 dismiss 退出
}
}.start();
***所有的控件都有的属性：visibility｛visible（默认，可见），invisible（不可见占空间）,gone（不可见也不占空间）｝
4. 自定义控件
开源框架：SmartImageView（看源码）---- SmartImageView.setImageUrl(Url url){}
1 . 继承原生控件
2 . 重写构造方法
3 . 根据业务需求定义方法
5. ListView
-1.作用和方法：用来将数据显示到屏幕上的技术
google按照mvc的三层架构思想设计
m：model--- 模型--- 需要显示的数据
v：view ---视图---- 呈现的界面
c：controller--- 控制器--- Adapter（适配器）
1. lv.setSelection(random1); //该方法可以 ListView 定位到让指定位置（random1），就是让指定位置的条目位于当前界面第一行。非常准确。
2. lv.smoothScrollToPosition(xxx); //该方法可以让 ListView 平滑的滚动到指定位置（xxx），但是非常不准确。
3. lv1.setOnScrollListener(OnScrollListener); //给ListView 设置监听器
4. //滑动时回调的方法
// scrollState 滚动状态有三种：0 静止，1 手指滑动，2惯性滚动
@Override
public void onScrollStateChanged(AbsListView view, int scrollState) { }
@Override
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {}
-2.BaseAdapter ---是ListAdapter的一个默认实现类
主要需要重写的2个方法：
public int getCount(){ //总共需要显示数据条数
return list.size();
}
public public View getView(int position, View convertView, ViewGroup parent) {
//三种填充View的方法,本质是一样的
//第一种
View view = View.inflate(MainActivity.this,R,layout.item_main,null);
//第二种
View view = LayoutInflater.from(MainMainActivity.this).inflate(R,layout.item_main,null);
//第三种
LayoutInflater ll = (LayoutInflater)getSystemService("LAYOUT_INFLATER_SERVICE");
View view = ll.inflate(R,layout.item_main,null);
}
-3.ArrayAdapter
listView.setAdapter(new ArrayAdapter(MainActivity.this,R.layout.item,T[] Objects));
最后一个参数也可以是集合。
-4.SimpleAdapter
待完善
-5.优化
（1）//删除之前已经显示的数据 ,然后再次重新加载进来,这样避免重复显示
if(myadapter ==null){
myadapter = new MyAdapter();
lv.setAdapter(myadapter);
}else{
//要通知适配器去更新一下数据
myadapter.notifyDataSetChanged();
}
（2）防止OOM（Out Of Memory）异常
View view;
if(convertView==null){
view = View.inflate(MainActivity.this, R.layout.item, null);
}else{
view =convertView;
}
或
if(convertView==null){
convertView = View.inflate(MainActivity.this, R.layout.item, null);
}
（3）faster（用Holder）持有器
static class ViewHolder ｛
TextView tv；
ImageView iv；
｝
View Holder holder；
if (convertView == null) {
convertView=View.inflate(MainActivity.this,R.layout.item,null);
holder = new ViewHolder();
holder.iv = (ImageView) convertView.findViewById(R.id.iv);
holder.tv_title = (TextView) convertView.findViewById(R.id.tv);
convertView.setTag(holder);
｝else｛
holder = (ViewHolder) convertView.getTag();
｝
##3.数据存储和解析
1. 文件存储
-1.基本输入输出流文件
-2.Context提供了两个方法来打开数据文件里的文件IO流，存储路径：/data/data//files
openFileInput("xxx.txt"); //读取
openFileOutput("xxx.txt",Context.MODE_PRIVATE); //保存
//MODE_PRIVATE：为默认操作模式，代表该文件是私有数据，只能被应用本身访问，在该模式下，写入的内容会覆盖原文件的内容
//MODE_APPEND：模式会检查文件是否存在，存在就往文件追加内容，否则就创建新文件;
//后面的两种模式在Android4.2被废弃,不安全
//MODE_WORLD_READABLE：表示当前文件可以被其他应用读取；
//MODE_WORLD_WRITEABLE：表示当前文件可以被其他应用写入。
deleteFile("xxx.txt"); //删除
File getFilesDir():获取该应用程序的数据文件夹得绝对路径
File getCacheDir():缓存区
String[] fileList():返回该应用数据文件夹的全部文件
-3.Sdcard 存储
1、调用Environment的getExternalStorageState()方法判断手机上是否插了sd卡,且应用程序具有读写SD卡的权限，如下代码将返回true
Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)
2、调用Environment.getExternalStorageDirectory()方法来获取外部存储器，也就是SD卡的目录,或者使用"/mnt/sdcard/"目录
File file = new File(Environment.getExternalStorageDirectory(),filename);
3、使用IO流操作SD卡上的文件
注意点：
手机应该已插入SD卡，对于模拟器而言，可通过mksdcard命令来创建虚拟存储卡
必须在AndroidManifest.xml上配置读写SD卡的权限
2. SharedPreferences存储 --- 单例，一般不会发生并发冲突
1.创建文件： SharedPreferences sp = context.getSharedPreferences("xxx",int mode);//创建的xxx一定是xml文件,存储在/data/data//shared_prefs,参数mode 和上面一样。
2.存储数据: Editor edit = sp.edit();
edit.putXxx(String key,Xxx value);
edit.commit(); || edit.apply();
区别： 1. apply没有返回值apply方法不会提示任何失败的提示。而commit返回boolean表明修改是否提交成功
2. apply异步提交数据，commit同步。
3.读取数据： sp.getXxx(String key,XxxDefault);// 如果没有读取到，就返回第二参数。
4.删除数据： sp.remove(String key);//删除key字段
sp.clear();//清空文件
3. SQLite数据库存储
-1.创建表
db.execSQL("create table tablename(_id integer primary key autoincrement,name varchar(30),age Integer)");
-2.Insert
第一种：存在sql注入问题
db.execSQL("insert into tablename(name,age) values('Myth',2)");
第二种：通过占位符？ 解决sql注入
db.execSQL("insert into tablename(name,age) values(?,?)",new Object[]{"Myth",2});
第三种：底层还是通过拼接字符串得到sql语句
ContentValues values = new ContentValues();
values.put("name","Myth");
values.put("age",2);
db.insert("tablename",columnNull,values);//第二个参数：sql表不允许插入空，所以就会用null当作该值插入表。
-3.Delete
db.execSQL("delete from tablename where _id = 2");
db.execSQL("delete from tablename where _id = ?",new Object[]{2});
db.delete("tablename","_id = ?",new String[]{String.valueOf(id)});
-4.Update
db.execSQL("update tablename set name = 'Myth' where age = 2");
db.execSQL("update tablename set name=?,age =? where _id=?",new Objecet[]{"Myth",2,2});
ContentValues values = new ContentValues();
values.put("name","Myth");
values.put("age",2);
db.update("tablename",values,"_id=?",new String[]{String.valueOf(id)});
-5.Query
Cursor cursor = db.rawQuery("select * from tablename where _id=2");
Cursor cursor = db.rawQuery("select * from tablename where _id=?",new Object[]{2});
Cursor cursor = db.query(table, columns, selection, selectionArgs, groupBy, having, orderBy, limit);
if(cursor.moveToFirst){
while(cursor.moveToNext){
}
}
4. SQLite实践
-1.事务操作 --- 同时处理多条数据时，保证数据安全性
db.beginTransaction();
try {
db.setTransactionSuccessful();//执行提交
} finally {
db.endTransaction();
}
-2.数据库升级操作 --- 保证版本更新成功
switch (oldVersion) {
case 1: //代表每个版本的操作 该case 是1~2的升级操作
case 2: //case 一直到最新版本
default:
}
-3.注意：getWritableDatabase()和getReadableDatabase()方法的区别：
getWriteableDatabase()方法以读写方式打开数据库一旦数据库的磁盘空间满了，数据库就只能读而不能写，倘若使用getWritableDatabase()打开数据库就会出错。
getReadableDatabase()方法先以读写方式打开数据库，如果数据库的磁盘空间满了，就会打开失败，当打开失败后会继续尝试以只读的方式打开数据库.
5. XML生成器：XmlSerializer和 XML解析器：XmlPullParser
-1.XmlSerializer：(字符串拼接Xm文件存在语句注入问题，so用XmlSerializer)
XmlSerializer serializer = Xml.newSerializer();
serializer.setOutput(fos,"UTF-8");
serializer.startDocument("UTF-8",true);// "
serializer.startTag(null, "smses");
for (int i = 0; i < 50; i++) {
serializer.startTag(null, "sms"); //第一个参数为命名空间
serializer.startTag(null, "body");
serializer.text("我是内容<>" + i);
serializer.endTag(null, "body");
serializer.endTag(null, "sms");
}
serializer.endTag(null, "smses");
serializer.endDocument;
fos.close;
-2.XmlPullParser：
XmlPullParser pullparser = Xml.newPullParser();
pullparser.setInput(fis,"UTF-8");
int eventType = pullparser.next();
while(eventType != XmlPullParser.END_DOCUMENT){
switch(eventType){
case XmlPullParser.START_TAG:
if ("smses".equals(tagName)) {
list = new ArrayList();
}else if ("sms".equals(tagName)) {
sms = new Sms();
}else if ("body".equals(tagName)) {
sms.setBody(parser.nextText());
}
break;
case XmlPullParser.END_TAG:
if ("sms".equals(tagName)) {
list.add(sms);
}
break;
}
eventType = pullparser.next();
}
##4.Activity
-1.自定义的Activity
-1.创建一个MyActivtiy实现Activity
public class MyActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
｝
-2.新建一个布局文件 xxx.xml
-3.在onCreate()方法里写 上 setContentView(R.layout.xxx）;
-4.最重要的一步：在清单文件中注册一个自己的Activity
android:name="com.example.MyActivity" //可以缩写.MyActivity
android:label="@string/app_name" > //标题栏的内容
-5.非必须的一步：隐藏标题栏 ---在onCreate()方法内写
requestWindowFeature(Window.FEATURE_NO_TITLE);
-2.生命周期
OnCreate() 创建界面
OnStart() 不可见---->可见 时候会调用
OnResume() 获得焦点，此时活动在栈顶，处于运行状态
OnPause() 失去焦点，不在栈顶但可见，处于暂停状态
OnStop() 可见---->不可见 时候会调用，处于停止状态
OnDestroy() 销毁
**注意：要使得Activity不可见，可以再建一个项目同时运行，将其Application的theme属性改成透明状态：
android:theme="@android:style/Theme.Translucent">
-3.活动的四种启动模式（android：launchMode=""）
-1.standard：每次启动acitvity组件时, 都会新创建activity 实例，是活动默认的启动模式
-2.singleTop：如果某个activity设置单一顶部模式, 那么当发现当前的activity就在当前任务栈的顶部, 那么就不再新创建当前的activity的实例.例如：系统的短信
-3.singleTask：如果当前任务栈中已经有当前activity 的实例, 那么就将当前activity 的实例直接拿过来用, 用的时候,如果当前activity 不在栈顶,那么将在当前activity 之上的其他的activity的实例 给干掉... 然后再处于栈顶了一般情况下, 当某个activity 启动的时候, 要占用的内存比较大, 而手机上的内存又是有限的, 那么这个时候, 就推荐将这个activity的启动模式设置为单一任务栈模式.例如：系统的浏览器
-4.singleInstance：如果某个activity 的启动模式设置为单一实例模式, 那么系统会为这个activity 单独的去开辟一个任务栈,这个任务栈中,只放这个 activity的实例.这样确保了整个操作系统中,只有一个这个activity的实例了.如果某个activity在整个系统中就只需要有一个实例, 并且永远不会更改, 那么就推荐使用这种模式.例如：系统的电话
-4.使用intent在活动之间传输数据
-1.显示意图：是明显的指定要激活哪个组件 ..一般建议用在应用程序内部 .
Intent intent = new Intent();
// intent.setClass(this, SecondActivity.class);
// intent.setClassName("com.itheima.exactintent", "com.itheima.exactintent.SecondActivity");
intent.setClassName(this, "com.itheima.exactintent.SecondActivity");
startActivity(intent);
-2.隐式意图：是指不明确到底哪个组件可以响应你的意图,你只需要将意图发出去就可以了.当存在满足你的意图的组件时,
这个时候,系统就会将组件给激活起来...一般用在不同应用程序之间 激活组件 ..
Intent intent = new Intent();
//必须和Activity下的intent-filter内容匹配
intent.setAction("com.itheima.nu");
// intent.addCategory("android.intent.category.DEFAULT");
intent.addCategory(Intent.CATEGORY_DEFAULT);
startActivity(intent);
****1. 每个应用中的组件是可以配置多个Intent-filter,可以配置多个隐式意图去激活这个组件
2. 如果想要激活这个组件, 只需要发送对应的隐式意图就可以了.
-3.intent中setData：接收一个Uri对象，例如：intent.setData(Uri.parse("www.baidu.com"));
与其对应，可以在标签中配置一个子标签。
属性：scheme（http），host（www.baidu.com），port（8080），path（指定端口号后面的部分），mimeType（指定可以处理的数据类型，允许使用通配符）
-4.intent携带数据，实现短信分享：
Intent intent = new Intent();
//短信有很多intent-filter，只需要其中匹配上一个即可
intent.setAction("android.intent.action.SENDTO");
intent.addCategory("android.intent.category.DEFAULT");
intent.addCategory("android.intent.category.BROWSABLE");
intent.setData(Uri.parse("smsto://xxxxx"));
intent.putExtra("sms_body", "xxxxxxxxxx");
startActivity(intent);
//Activity接收数据
Intent intent = getIntent();
String data = intent.getExtraString("sms_body");
-5.带有返回结果的intent
主Activity：
Intent intent2 = new Intent();
intent2.setClass(this, xxx.class);
startActivityForResult(intent2, 2);
//接收其他Activity回传的结果数据
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
System.out.println("结果返回到这里了 ....");
if(requestCode==1){
}else if(requestCode==2){
}
super.onActivityResult(requestCode, resultCode, data);
}
xxxActivity:
Intent data = new Intent();
data.putExtra("contact", contact);
setResult(0, data);
finish(); // 关闭该xxxActivity
-6.其他
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);重新启动Activity
intent.addAction("android.media.action.IMAGE_CAPTURE");启动相机
##5.BroadcastReceiver（买收音机，装电池，调频道）
-1.动态注册广播接收者
（1）监听手机屏幕开关
receiver = new ScreenStateReceiver();//继承BroadcastReceiver
IntentFilter filter = new IntentFilter();
filter.addAction("android.intent.action.SCREEN_OFF");
filter.addAction("android.intent.action.SCREEN_ON");
registerReceiver(receiver, filter);//注册 广播接收者
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if("android.intent.action.SCREEN_OFF.equals(action)){
System.out.println("发现用户屏幕关了 ");
abortBroadcast();//拦截广播
}else if("android.intent.action.SCREEN_ON".equals(action)){
System.out.println("发现用户屏幕开启 ");
}
}
（2）监听网络变化
receiver = new NetworkChangeReceiver();//继承BroadcastReceiver
IntentFilter filter = new IntentFilter();
filter.addAction("android.intent.action.CONNECTIVITY_CHANGE");
registerReceiver(receiver, filter);//注册 广播接收者
(3)需要手动取消注册
在onDestroy（）中调用 unregisterReceiver（receiver）；
-2.静态注册一个广播接收者 --- 监听开机启动
//优先级-1000~10000，优先接收广播
-3.发送无序广播
// 定义 intent , intent 设置 必要的信息就可以 了
Intent intent = new Intent();
intent.setAction("com.example.xxx");
// 发送 广播
sendBroadcast(intent);
-4.发送有序广播
// 定义 intent , intent 设置 必要的信息就可以 了
Intent intent = new Intent();
intent.setAction("com.example.xxx");
// 发送 广播
sendOrderBroadcast(intent，null);//第二个参数是一个与权限有关的字符串
##6.Server
-1.Handler异步消息处理机制（IPC 线程通信，避免发生ANR 问题，在Activity中 耗时操作 5s 产生ANR。）
-1.Message：线程间传递消息，
//获得消息对象，两种方式本质一样
Message msg = handler.obtainMessage();
Message msg = Message.obtain();
msg.sendToTarget(); //该msg需要绑定handler，从handler.obtainMessage()获取
-2.Handler：用于发送和处理消息
handler.sendMessage();
handler.sendEmptyMessage();//发送无效消息
private Handler handler = new Handler(){
public void handleMessage(android.os.Message msg) {
switch (msg.what) {
case SUCCESS:
Xxx data = (Xxx)msg.obj;
Toast.makeText(MainActivity.this, "成功", 0).show();
break;
case FAILURE:
Toast.makeText(MainActivity.this, "失败", 0).show();
break;
}
}
};
-3.MessageQueue :消息队列，存放将要被处理的消息，每个线程只有一个MessageQueue
-4.Looper：调用loop()，进入一个无线循环中，不断取出MessageQueue中的消息传递到handleMessage()中，每个线程也只有一个Looper对象。
-5.发送消息代码
Message msg = Message.obtain();
msg.what = SUCCESS; // what 区分发送的消息类型
msg.obj = data; // obj 携带任意消息
handler.sendMessage(msg);
-2.AsyncTask ---Android已经封装好，方便在子线程中对UI进行操作。（待更新）
-3.进程优先级分类:
-1.前台进程: 就是正在与用户进程交互的引用程序
-2.可视进程: 用户看得见的,但是摸不着的
-3.服务进程: 在服务中运行, 在后台运行着
-4.后台进程: 在后台一直运行着,不是运行在service ,是运行在activity中
-5.空进程: 引用程序已经退出了,没有activity,没有service .
-6.总结：前台进程> 可视进程> 服务进程> 后台进程> 空进程 当系统内存不够用的时候, 就会去尝试回收进程,来重新分配内存. 会按照如上优先级分类杀掉进程.
-4.自定义服务
public class MyService extends Service {
@Override
public IBinder onBind(Intent intent) {
return new MyBinder();
}
}
// 必须清单文件注册
-5.开启服务的生命周期
onCreate() //服务创建时调用
onStartComment() //每次服务启动时调用，废弃了onStart()
onDestroy() //服务销毁时调用
-1.开启服务
Intent intent = new Intent();
intent.setClass(MainActivity.this,MyService.class);
startService(intent);
-2.停止服务
Intent intent = new Intent();
intent.setClass(MainActivity.this,MyService.class);
stopService(intent);
-6.绑定服务的生命周期
onCreate() //创建服务
onBind() //绑定服务
onUnbind() //解除绑定服务
onDestroy() //销毁服务
(1)绑定服务时, onStartCommand并不会执行,
(2)绑定服务,服务何时销毁呢, 在应用程序退出的时候就销毁了
(3)绑定服务, 服务不会在后台运行 ---在apps中running 中是看不到的
(4)开启服务, 服务会在后台运行--- 可以在apps中 runnning 中看到
(5)绑定服务, 服务只会创建一次, 如果再次绑定服务, 那么服务是不会重新再次创建的.
(6)如果没有绑定服务, 就直接去解绑服务, 那么会抛异常.so 需要做如下判断，避免异常
if(conn != null){
unbindService(conn);
conn = null;
mybinder = null;
}
-7.绑定服务实现流程（活动和服务间通信，进程间通信使用 IBinder）
-1.绑定服务
Intent intent = new Intent();
intent.setClass(this, MyService.class);
if(conn == null){
conn = new MyConnection();
}
bindService(intent, new MyConnection(), BIND_AUTO_CREATE);
-2.编写MyBinder 继承 Binder 实现 IService // IService 接口中是将要调用的方法
private class MyBinder extends Binder implements IService{
@Override
// 服务中对外提供的方法封装在接口中，重写接口中的方法
public void call(String name, String service) {
calle(name, service);
}
//该方法为不对外提供的方法，只对内访问
public void callee(String name, String service) {
System.out.println("呼叫前台");
}
}
-3.向Activity传回MyBinder对象
@Override
public IBinder onBind(Intent intent) {
return new MyBinder();
}
-4.实现MyConnection 实现 ServiceConnection接口
private class MyConnection implements ServiceConnection{
@Override
//当与服务建立联系的时候被回调
public void onServiceConnected(ComponentName name, IBinder service) {
if(mybinder == null){
mybinder = (IService) service;
// mybinder = IService.Stub.asInterface(service);
}
}
@Override
//当与服务断开联系的时候被回调
public void onServiceDisconnected(ComponentName name) {
mybinder = null;
}
}
-5.调用服务中的方法
mybinder.call("xxxx", "xxxx");
-8.不同Activity之间通信
主要编写.aidl
(1)语法与接口很类似，直接修改接口文件后缀名即可。但是.aidl文件中不能写权限修饰符
(2).aidl文件接受参数和返回值类型是8种基本数据类型，如果是引用数据类型，必须实现Parceable接口
(3)不能修改.aidl文件生成的.java类
-1 Parceable 比 Serializable 性能高
-2 Serializable 使用时会产生大量临时变量，引起频繁的GC
-3 Parceable 不能保证数据的持续性，不能使用数据保存在磁盘上
-9.混合开发服务
(1)开启服务：只能在后台运行
(2)绑定服务：只能调用服务中的方法
想在后台运行,但是同时又想 调用服务中 方法, 那么 就需要混合开启服务了.
以后,如果需要在后台运行, 并且又需要调用服务中的方法时,请严格按照 如下的顺序去 实现程序的逻辑, 否则 就容易出现问题..
混合开启:
开启服务
绑定服务
调用服务中的方法
解除绑定
停止服务
例如：QQ 在退出的时候,选择退出后, 仍然可以接受消息, 就可以使用混合开启服务的方式...
-10.Android提供一个IntentService类：是一个异步的，会自动停止的服务，可以避免ANR问题（服务在主线程中耗时操作 10s 产生ANR 问题）
public class MyIntentService extends IntentService {
public MyIntentService() {
super("MyIntentService");
}
@Override
protected void onHandleIntent(Intent intent) {
} //处理具体的逻辑
}
// 清单文件注册
##7.ContentProvider
-1.自定义内容提供者 ---ContentProvider
public class MyContentProvider extends ContentProvider {
private static final int SUCCESS = 0;
private static UriMatcher matcher;
//匹配器 -- UriMatcher
//是固定的写法
//这里的no_match是用来指定当匹配不成功时,返回的值
static {
matcher = new UriMatcher(UriMatcher.NO_MATCH);
// com.itheima.xxx 公开的名称, table就是暗号了, SUCCESS指匹配成功后返回的结果
matcher.addURI("com.example.xxx", "table", SUCCESS);
}
@Override
public boolean onCreate() {
return false;
}
@Override
public Cursor query(Uri uri, String[] projection, String selection,
String[] selectionArgs, String sortOrder) {
BankOpenHelper myOpenHelper = new MyOpenHelper(getContext());
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
if (matcher.match(uri) == SUCCESS) {
return db.query("table", projection, selection, selectionArgs, null,
null, sortOrder);
}
return null;
}
@Override
public String getType(Uri uri) {
return null;
}
@Override
public Uri insert(Uri uri, ContentValues values) {
BankOpenHelper myOpenHelper = new MyOpenHelper(getContext());
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
// TODO Auto-generated method stub
if (matcher.match(uri) == SUCCESS) {
db.insert("table", null, values);
} else {
try {
throw new Exception("暗号错误。");
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
BankOpenHelper myOpenHelper = new MyOpenHelper(getContext());
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
if (matcher.match(uri) == SUCCESS) {
return db.delete("account", selection, selectionArgs);
}
return 0;
}
@Override
public int update(Uri uri, ContentValues values, String selection,
String[] selectionArgs) {
BankOpenHelper myOpenHelper = new MyOpenHelper(getContext());
SQLiteDatabase db = myOpenHelper.getWritableDatabase();
if (matcher.match(uri) == SUCCESS) {
return db.update("account", values, selection, selectionArgs);
}
return 0;
}
}
##清单文件注册：
-2. 内容解析者 ---- ContentResolver (类似SQLite操作)
1 insert
ContentResolver resolver = getContentResolver();
Uri url = Uri.parse("content://com.example.xxx/table");
ContentValues values = new ContentValues();
values.put("key", "value");
resolver.insert(url, values);
2.delete
ContentResolver resolver = getContentResolver();
Uri url = Uri.parse("content://com.example.xxx/table");
resolver.delete(url, "key=?", new String[]{"value"});
3.update
ContentResolver resolver = getContentResolver();
Uri url = Uri.parse("content://com.example.xxx/table");
ContentValues values = new ContentValues();
values.put("key1", "value1");
resolver.update(url, values, "key=?", new String[]{"value"});
4.query
ContentResolver resolver = getContentResolver();
Uri url = Uri.parse("content://com.example.xxx/table");
Cursor cursor = resolver.query(url, null, "key=?", new String[]{"value"}, null);
while(cursor.moveToNext()){
}
-3.内容观察者 --- ContentObserver
（1）ContentResolver resolver = getContentResolver();
//注册一个内容观察者
//如果notifyForDescendents参数设为true,假如Uri为content://abc,那么Uri为content://abc/xyz, content://abc/xyz/foo的数据改变时也会触发该监听器，如果参数为false，那么只有content://abc的数据改变时会触发该监听器
resolver.registerContentObserver(uri, boolean notifyForDescendents, new ContentObserver(null) {
// selfChange : 数据的变化是否是来自于自己
@Override
public void onChange(boolean selfChange) {
System.out.println("数据发生变化了 ....");
}
});
（2）在不需要时，需要手动的调用
unregisterContentObserver()去取消注册。
（3）ContentObserver类介绍
构造方法 public void ContentObserver(Handler handler) ｛｝
说明：所有 ContentObserver的派生类都需要调用该构造方法
参数： handler Handler对象。可以是主线程Handler(这时候可以更新UI了)，也可以是任何Handler对象。
##8.手机多媒体
-1.通知的使用（NotificationManager）
-1.第一种
//拿到通知管理器
NotificationManager nm = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
Notification nf = new Notification(R.drawable.ic_launcher,"This is ticker Text ",System.currentTimeMillis());
// 第四个参数为延期意图（能跳转干你想干的事）
nf.setLatestEventInfo(context, "This is content title", "This is content text", null);
//显示通知，第一个参数是每一个通知的id（保证不同）
nm.notify(1,nf);
-2.第二种
//基于Notification是builer模式构建，可以链式编程创建
Notification nf = new Notification.Builder(this)
.setContentTitle("你有消息") //标题
.setContentText("你mama 喊你回家吃饭") //文本
.setSmallIcon(R.drawable.ic_launcher) //小图标
.setLargeIcon(BitmapFactory.decodeResource(getResources(),
R.drawable.ic_launcher)) //大图标
.build();
NotificationManager nm = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
nm.notify(1,nf);
-3.通过pending（延期意图）拨打电话
Notification nf = new Notification(R.drawable.ic_launcher, "你好一有消息", System.currentTimeMillis());
Intent intent = new Intent();
intent.setAction(Intent.ACTION_CALL);
intent.setData(Uri.parse("tel:"+5556));
// pendingIntent 可以getActivity（） getService（） getBroadcast（）
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, 0);
nf.setLatestEventInfo(this, "ai", "huijiachifan", pendingIntent);
//权限不能少,打电话权限
-2.短信的接收和发送（SmsManger）
-1.接收短信：监听 android.provider.Telephony.SMS_RECEIVED的广播
public class MessageReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Bundle bundle = intent.getExtras();
//通过密钥"pdus"获取SMS pdu 数组，每一个pdu是一条短信
Object[] objects = (Object[])bundle.get("pdus");
for (Object object : objects) {
//将每一个pdu字节数组转换SmsMessage对象
SmsMessage smsMessage = SmsMessage.createFromPdu((byte[])object);
//获取短信的发送方号码
if(smsMessage.getOriginatingAddress().equals("55666")){
//获取短信
smsMessage.getMessageBody();
}
}
}
}
//接收短信权限
-2.发送短信
SmsManager smsManager = SmsManager.getDefault();
//发送很长很长的短信需要切割短信存到集合中，才能一条一次性发出去
ArrayList divideMessage = smsManager.divideMessage("");
smsManager.sendMultipartTextMessage("phone", null, divideMessage, null, null);
//接收短信权限
-3.监听手机状态（TelephonyManager）:开启录音功能（MediaRecoder）
TelephonyManager manager = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
manager.listen(new myPhoneStateListener(), PhoneStateListener.LISTEN_CALL_STATE);
private class myPhoneStateListener extends PhoneStateListener{
@Override
public void onCallStateChanged(int state, String incomingNumber) {
// TODO Auto-generated method stub
super.onCallStateChanged(state, incomingNumber);
switch (state) {
if(mRecorder != null){
stopRecording();
}
break;
case TelephonyManager.CALL_STATE_OFFHOOK:
startRecording();
break;
case TelephonyManager.CALL_STATE_RINGING:
break;
default:
break;
}
}
}
MediaRecorder mRecorder;
private void startRecording() {
//下面是模版，可以录音文件的格式有：3gp，mp3。。。
mRecorder = new MediaRecorder();
mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
mRecorder.setOutputFile("/mnt/sdcard/jianting.3gp");
mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
try {
mRecorder.prepare();
} catch (IOException e) {
// Log.e(LOG_TAG, "prepare() failed");
}
mRecorder.start();
}
private void stopRecording() {
mRecorder.stop();
mRecorder.release();
mRecorder = null;
}
//录音权限，读手机状态权限
-4 播放音视频（MediaPlayer）
setDataSource() // 设置要播放
seekTo()// 从指定位置播放
isPlaying()//当前是否播放
getDuration// 获取音频时长
// 开始播放Button
public void start(View v){
//播放的地址
String dizhi = et_shu.getText().toString().trim();
if(TextUtils.isEmpty(dizhi)){
Toast.makeText(this, "不能为空", Toast.LENGTH_SHORT).show();
return;
}
player = new MediaPlayer();
player.reset();
try {
player.setDataSource(dizhi);
player.prepare();
//异步准备
/*player.prepareAsync();
player.setOnPreparedListener(new OnPreparedListener() {
@Override
public void onPrepared(MediaPlayer mp) {
// TODO Auto-generated method stub
player.start();
}
});*/
player.start();
} catch (Exception e) {
e.printStackTrace();
}
}
// 暂停Button
public void pause(View v){
if(player!= null && player.isPlaying()){
player.pause();
return;
}
if(player!= null){
player.start();
}
}
// 停止Button
public void stop(View v){
if(player!= null){
player.stop();
player.release();
player = null;
}
}
-5.传感器的使用（SensorManager）
SensorManager sm = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
// Sensor.TYPE_XXX 可以获取
Sensor lightSensor = sm.getDefaultSensor(Sensor.TYPE_XXX);
MySensorEventListener myListenser = new MySensorEventListener();
// 必须注册监听事件，第二个参数 是Senor实例，第三个参数是 传感器输出信息的更新速率
有4个值：SENSOR_DELAY_UI SENSOR_DELAY_NORMAL SENSOR_DELAY_GAME SENSOR_DELAY_FASTEST 越来越快，耗电
sm.registerListener(myListenser, XXXSensor, SensorManager.SENSOR_DELAY_NORMAL);
}
// 不使用的时候取消监听，省电
@Override
protected void onDestroy() {
super.onDestroy();
if(myListenser!=null){
sm.unregisterListener(myListenser);
}
}
private class MySensorEventListener implements SensorEventListener{
// sensor获得周围环境数据发生变化时 ,会被调用
@Override
public void onSensorChanged(SensorEvent event) {
//编写逻辑事件
}
// sensor获得周围环境数据发生变化时,精确度发生变化时会被调用
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
}
// 获取Sensor.TYPE_ALL
List list = sm.getSensorList(Sensor.TYPE_ALL);
System.out.println("数量 : " + list.size());
for (Sensor sensor : list) {
System.out.println(sensor.getName() +" , 类型 值 : " + sensor.getType());
}
##9.网络编程
-1.HttpURLConnection
1.get请求（拼接URL。。）
//防止乱码 URL编码
String username = URLEncoder.encode(username, "UTF-8");
String password = URLEncoder.encode(password, "UTF-8");
URL url = new URL(path+"?username="+username+"&password="+password);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
//伪装设置成windows端查看网页
//conn.setRequestProperty("User-Agent",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2486.0 Safari/537.36 Edge/13.10586");
//设置连接超时时间
conn.setConnectTimeout(5000);
//获取响应码
int code = conn.getResponseCode();
2.post请求
URL url = new URL(path);
String params = "?username="+URLEncoder.encode(username, "UTF-8")+"&password="+URLEncoder.encode(password, "UTF-8");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
//设置连接超时时间
conn.setConnectTimeout(5000);
//获取响应码
conn.setDoOutput(true);
conn.getOutputStream().write(params.getBytes());
int code = conn.getResponseCode();
-2.HttpClient(Apache) ---android 6.0 废弃
1.get请求
username = URLEncoder.encode(username, "UTF-8");
String path = "http://169.254.26.249:8080/qqlogin/servlet/login?username="+username+"&password="+password;
DefaultHttpClient client = new DefaultHttpClient();
HttpGet get = new HttpGet(path);
//执行请求，拿到响应对象
HttpResponse response = client.execute(get);
int code = response.getStatusLine().getStatusCode();
if(code == 200){
//拿到服务端响应的输入流
InputStream is = response.getEntity().getContent();
String login = StreamTool.decodeStream(is);
2.post请求
String path = "http://169.254.26.249:8080/qqlogin/servlet/login";
DefaultHttpClient client = new DefaultHttpClient();
HttpPost post = new HttpPost(path);
//通过一个NameValuePair集合来存放待提交的数据
List list = new ArrayList();
list.add(new BasicNameValuePair("username", username));
list.add(new BasicNameValuePair("password", password));
//防止乱码
post.setEntity(new UrlEncodedFormEntity(list , "UTF-8"));
//执行请求，拿到响应对象
HttpResponse response = client.execute(post);
int code = response.getStatusLine().getStatusCode();
if(code == 200){
InputStream is = response.getEntity().getContent();
String login = StreamTool.decodeStream(is);
-3.AsyncHttpClient---post请求
AsyncHttpClient client = new AsyncHttpClient();
RequestParams params = new RequestParams();
params.add("username", username);
params.add("password", password);
client.post(path, params, new AsyncHttpResponseHandler() {
@Override
//statusCode 是 响应码 headers响应头 responseBody 响应体
public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
Toast.makeText(MainActivity.this,"登录结果为"+new String(responseBody), 0).show();
}
@Override
public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
Toast.makeText(MainActivity.this,"登录结果为"+new String(responseBody), 0).show();
}
