在大学期间，我的Android跌跌撞撞的学了一年。我上学时代对于知识的整理还是蛮痴迷的，可惜当时不会使用markdown（富文本让我头昏脑胀）。如今在利用晚上睡觉、工作之余把大学的Android用markdown整理了一遍。供学弟学妹们参考书使用。

超长篇！！大量小白(学生)操作！！高手止步！！
当然，后续笔记中，我会补充很多企业级写法、常用框架、底层代码、flutter、RN等，以供大家参考！

第一节 基础布局

• 0.常用属性

layout_width[宽]、layout_height[高] 其属性包含(match_parent填充窗体、wrap_content包裹内容)
layout_marginTop上外边距
layout_weight(设置权重(要实施权重的方向不能设置为填充))

• 1.线性布局(LinearLayout)

它主要以水平与垂直的方式来显示界面控件。当控件水平排列时(显示从左到右)，当控件垂直排列时，显示顺序从上到下。
线性布局中有一个非常重要的属性orientation。用于控制排列方向。（两个值horizontal[水平]于vertical[垂直]）

如何让线形布局中的控件居中呢？
layout_gravity属性只有根布局是LinearLayout的情况下才能使用。表示子布局在父布局中的显示方式：
layout_gravity有以下几种值：
center：居中（横向和纵向均居中）
center_horizontal：水平居中
center_vertical：垂直居中

• 2.相对布局(RelateiveLayout)

相对布局是通过相对定位的方式指定控件位置，在设计的时候要遵循控件之间的依赖关系。其内部的属性较多，比较常用的是以下几个
layout_centerInParent位于父布局中央位置
layout_centerVertical位于父布局垂直居中位置
layout_centerHorizontal位于父布局水平居中位置
layout_above当前控件位于某控件上方
layout_below当前控件位于某控件下方
layout_toLeftOf当前控件位于某控左侧
layout_toRightOf当前控件位于某控右侧
layout_alignBottom和某控件的底部对齐
layout_alignParentBottom当前控件是否与父控件底部对齐

• 3.帧布局(frameLayout)

帧布局是最简单的一种布局模式，该布局为每一个控件都创造一个空白区域。安装先后顺序重叠摆放(先放入的显示在最底层)
foreground属性设置容器前景(始终在所有子控件至上)

• 4.表格布局(TableLayout)

表格布局是以表格形式排列控件的，表格布局需要tableRow配合使用，每一行都由tableRow决定

• 5.绝对布局(AbsoluteLayout)「已经废弃」

• 6.网格布局(GridLayout)「android4.0出现」

• 7.约束布局(ConstraintLayout)「维护太费劲」

第二节 Android常用控件

• 1.TextView 用于显示文字信息

gravity="center"    居中显示

• 2.EditText 继承于TextView进行可编辑操作(文本框)

hint="提示"      //用于文本框提示
maxLines="1"    //设置最大行数
backgroud="@null"  //不设置会出现一道蜜汁下划线

• 3.Button 按钮 响应点击事件

/*
 *三种实现方式（java8以后lambda表达式也成为第四种大家较为常用的方式之一）
 */
//1. 用onClick="click"标签 在对应的activity中实现该方法
    Button myBtn_one = (Button)findViewById(R.id.bt_one);
    public void click(View view){//参数很重要
        myBtn_one.setText(按钮已被点击);
    } 
        
//2. 用匿名内部类实现
    myBtn_one.setOnClickListener(new View.OnClickListener(){
        public void onClick(View v){
            myBtn_one.setText(按钮已被点击);
        }
    })
            
//3. 在当前Activity实现OnClickListener接口
    myBtn_one.setOnClickListener(this);
    public void onClick(View v){
        switch(v.getId){
            case R.id.bt_one:
                break;
            default:
                break;
        }
    }

• 4.RadioButton单选按钮

//RadioButton必须放到RadioGroup中去
    RadioGroup rg=(RadioGroup)findViewById(R.id.bt_two);
    rg.setOnClickedChangedListener(new RadioGroup.OnClickedChangedListener{
         public void onCheckedChanged(RadioGroup rg,int checkedId){
              if(checkedId == R.id.rbtn){
                  //具体操作
              }
         }
     })

• 5.ImageView 视图控件
  可以从各种来源加载图像，并提供缩放、裁剪、着色等功能。

backgroud="@drawable/bg"//拉伸
src="@drawable/bg"//不拉伸

第三节 常见对话框

对话框是程序与用户交互的一种方式，通常用于显示当前程序提示信息以及相关说明，以小窗口形式展现。常见有以下几种：

• 1.普通对话框

链式调用：

AlertDialog ad=new AlertDialog.Builder(this)
         .setTitle("Dialog对话框")//设置标题
         .setMessage("是否确定退出")//设置提示信息
         .setIcon(R.mipmap.ic_launcher)//设置图标
         .setPositiveButton("确定",null)//添加确定按钮
         .setNegetiveButton("取消",null)//设置取消按钮
         .create();
ad.show();

2.单选对话框

AlertDialog ad=new AlertDialog.Builder(this)
         .setTitle("请选择性别")//设置标题
         .setIcon(R.mipmap.ic_launcher)//设置图标
         .setPositiveButton("确定",null)//添加确定按钮
         .setSingleChoiceItems(new String[]{"男","女"},0,new DialogInterFace.OnClickListener(){ 
             /*参数0表示默认选择第一个，-1可表示没有默认选中*/
              public void onClick(DialogInterFace Dialog,int which){
              }
          })
         .create();
ad.show();

3.多选对话框

AlertDialog ad=new AlertDialog.Builder(this)
         .setTitle("请选择兴趣爱好")//设置标题
         .setIcon(R.mipmap.ic_launcher)//设置图标
         .setPositiveButton("确定",null)//添加确定按钮
         .setMultiChoiceItems(new String[]{"旅游","美食","汽车","购物"},null,null)
         .create();
ad.show();

4.进度条对话框

ProgressDialog dialog=new ProgressDialog(this);
dialog.setTitle("进度条对话框");
dialog.setIcon(R.mipmap.ic_launcher);
dialog.setMessage("正在下载请稍后")
dialog.setprogressStyle(ProgressDialog.STYLE_HORIZONTAL);//设置样式
dialog.show；

5.消息对话框
Toast.makeText(this,"提示信息",Toast.LENGTH.LONG).show();

6.自定义对话框
自己做一个对话框my_dialog.xml,建一个类 继承系统的 DiaLlog.

class MyDialog extends Dialog{
     private TextView tvMsg;
     private String dialogName;
     private Button btnOK;//确认按钮
     private Button btnCancel;//取消按钮
                
     public MyDialog(Context context,String dialogName){
          super(context);
          this.DialogName=dialogName;
     }
     protected void onCreate(Bundle savedInstanceState){
          super.onCreate(savedInstanceState);
          requestWindFeature(Windos.FEATURE_NO_TITLE);//去处标题
          setContentView(R.layout_mydialog);//引入自定义的对话框布局文件
          tvMsg=(TextView)findViewByIdViewById(R.id.tv_msg);
          Button btnOK =(Button)findViewByIdViewById(R.id.tv_ok);
          Button btnCancel =(Button)findViewByIdViewById(R.id.tv_Cancel);
          vMsg.setText(dialogName);
          btnOK.setOnClickListener(new View.OnClickListener(){
               public void onClick(View v){
               }
          });
         btnCancel.setOnClickListener(new View.OnClickListener(){
               public void onClick(View v){
                   dismiss();
               }
         });
     }
}

调用：

MyDialog myDialog=new MyDialog(this,"我是要提示的字");
myDialog.show;

第四节 view其他细节

一、样式(一般作用在控件上)

在res-->values-->styles.xml中：

<style name="textStyle"><!--也可以继承(parent="")-->
    <item name="android:layout_width">match_parent</item>
</style>

使用的时候
style="@style/textStyle"

二、主题（一般作用在activity或者application上）

在res-->values-->styles.xml中
内容与样式相同
使用的时候： 在清单文件AndroidManifest.xml
<activity android:name=".MainActivity" android:theme="@style/textStyle">//加入该行

三、国际化(别名 i18n)

在res-->values-->创建string.xml文件、选择locale 选择相应国家然后编写属性（可以加多个国家）

四、单元测试

在项目创建之时，软件已经为我们创建了androidTest包与aoolication类，所有测试功能模块写入此类即可

五、LogCat的使用

六、debug调试

F8走到下一行 绿色播放键 走到下一个断点， F7走入方法内部

七、其他

android焦点的概念 就相当于windows中的光标
像你做登录程序的话，密码输入错误，焦点是不是要聚焦密码框好点，这样就不用鼠标去点密码框然后再输入密码，这样有利于用户体验。
比如在一个界面上你点击按钮，那么焦点就聚集在这个按钮上。

八、两种得到上下文的方法

1.因为activity继承了activity所以可以用this
2.直接用getApplicationContext()

第五节 Android中的动画

一.帧动画(Drawable Animation)【2.3不兼容（认为是耗时操作）】

就是加载一系列的图片资源，在drawable下建立一个xml文件[例：dome.xml]

<animation-list xmlns:android="http://schemas.android.com/apk/res/android" android:oneshot="true"> <!--是否执行一次 -->
      <item android:drawable="@drawable/rocket_thrust1" android:duration="200" />
      <item android:drawable="@drawable/rocket_thrust2" android:duration="200" />
      <item android:drawable="@drawable/rocket_thrust3" android:duration="200" />
</animation-list>

在显示页面

ImageView rocketImage = (ImageView) findViewById(R.id.rocket_image);
rocketImage.setBackgroundResource(R.drawable.dome);//设置背景
rocketAnimation = (AnimationDrawable) rocketImage.getBackground();//加载类型
rocketAnimation.start();//开启动画

二.view动画（也叫补间动画）

• 【1】透明AlphaAnim

ImageView Image = (ImageView) findViewById(R.id.rocket_image);
//1表示完全不透明，0表示完全透明
AlphaAnimation aa = new AlphaAnimation(1.0f,0.0f)
aa.setDuration(2000);//执行时间
aa.setRepeatCount(1);//重复次数(不重复为0)
aa.setRepeatMode(Animation.REVERSE);//动画效果
Image.startAnimation(aa);

• 【2】旋转rotateAnim

//RotateAnimation ra=new RotateAnimation(0,360)
RotateAnimation ra=new RotateAnimation(0,360,Animation.RELATIVE_TO_SELF,0.5f,RELATIVE_TO_SELF,0.5f);
ra.setDuration(2000);//执行时间
ra.setRepeatCount(1);//重复次数(不重复为0)
ra.setRepeatMode(Animation.REVERSE);//动画效果
Image.startAnimation(ra);

• 【3】缩放scaleAnim

ScaleAnimation sa=new ScaleAnimation(1f,2f,1f,2f,Animation.RELATIVE_TO_SELF,0.5f,Animation.RELATIVE_TO_SELF,0.5f)//放大(前四个参数)
sa.setDuration(2000);//执行时间
sa.setRepeatCount(1);//重复次数(不重复为0)
sa.setRepeatMode(Animation.REVERSE);//动画效果
Image.startAnimation(as);

• 【4】位移translateAnim(不会改变真实位置)
• 【5】一起用
  AnimationSet set =new AnimationSet(true)
  xml方式 定义补间动画
  res目录下创建anim文件夹,建立alpha文件

<alpha xmlns:android="http://schemas.android.com/apk/res/android"
      android:fromAlpha="1.0f"
      android:toAlpha="0.0f"
      android:duration="3000"
      android:repeatCount="1"
      android:repeatMode="restart" />

Animation animation = AnimationUtils.loadAnimation(getApplicationContext(), R.anim.anim);
Image.startAnimation(animation);

三.属性动画(真实的改变控件)

ObjectAnimator oa=ObjectAnimator.ofFloat(iv."scaleY",0.1f,2,1,2);
oa.setDuration(2000);
oa.start();

第六节 Android中Activity

一个activity管理一个页面
setContentView(R.layout.factivity);决定加载哪个布局

一.activity的创建：

(五个状态、六个方法)
启动、运行、暂停、停止、销毁

onCreate()创建时调用、onStart()即将可见时调用、onResum()获取焦点与用户交互时调用
onPause()被覆盖或锁屏时调用、onStop()对用户不开见时调用、onRestart()从停止再启动时调用、onDestroy()销毁时调用

二.android的任务栈

一个应用对应一个任务栈(点开应用就会建立)
当页面启动时，页面对应的activity进栈。
按后退键，页面对应的activity就出栈
用户操作的页面永远是栈顶页面

三.activity的四种启动模式

在清单文件中。每一个activity都对应一个<activity>标签、其中的android:launchMode声明了启动方式

<activity android:name=".MainActivity" android:launchMode="standard">

默认为standard(即标准启动)：每一次启动activity就在任务栈顶创建一个新的实例。
singleTop：创建检查任务栈栈顶，如果有实例就会复用(覆盖)该实例，不会创建新实例(浏览器书签)
singleTask：创建检查整个任务栈，如果栈内出现相同activity即复用该实例，并把该activity之上的实例全部清空(保证只有实例存在，浏览器页面)
singleInstance：会为实例单独创建任务栈(系统电话来电)

四.意图(Intent)

主要用于activity、server、发送广播
根据开启组件的方式不同，意图被分为两种(显式意图、隐式意图)

• 显式意图：可以通过名称开启、指定目标组件

Intent intent=new Intent(this,MainActivity.class);
//参数：上下文+目标activity的字节码文件（指定具体类名）
startActivity(intent);

• 隐式意图：通过指定action和category等属性，系统根据这些属性进行分析后寻找activity清单文件的意图过滤器：(action表示执行动作，category表示条件)

<intent-filter>
   <action android:name="cn.yijiajia.hh" />
   <category android:name="android.intent.category.LAUNCHER"/>(.LAUNCHER表示启动页面；.DELAULT表示普通)
</intent-filter>

Intent intent=new Intent();
intent.setAction("cn.yijiajia.hh");
intent.addCategory("android.intent.category.DELAULT");
startActivity(intent);

使用时间（显示意图更安全）
1.开启自己写的界面用显示意图
2.开启其他应用的界面（大多数指系统应用）用隐式意图

第七节 Activity操作

一、Activity之间的跳转

二、Activity之间数据传递

1.打开网页：

intent.setDate(Uri:parse("http://www.baidu.com"));
startActivity(intent);

2.传递信息：

Intent intent=new Intent(this,MainActivity.class);
intent.putExtra("date","你好");//背地里用map进行封装
startActivity(intent);
            
Intent intent=getIntent();
String date =intent.getStringExtra("date");//    String date data=intent.getStringExtra("date","默认");

3.数据的回传

• 页面一

Intent intent=new Intent(this,Activity2.class);
startActivityForResult(intent,1);
//使用startActivityForResult方法开启一个新的activity，第一个参数是intent对象，第二个参数是请求码，用于判断来源

• 页面二

Intent intent=new Intent();
intent.putExtra("date","你好");
setResult(1,intent);

• 页面一

protected void onActivityResult(int requestCode,int resultCode,Intent date){
//本页面开启的页面关闭的时候执行（做数据回传的时候调用）[resultCode判断数据从哪来]
    super.onActivityResult(requestCode,resultCode,date);
    if(requestCode==1){
        if(resultCode==1){
            String string=data.getStringExtra("data")
        }
    }
}

4.关闭页面 finish();

四、Activity的启动模式

五、常见activity

1.拨打电话

Intent intent = new Inetent();
intent.setAction(Intent.ACTION_CALL);
intent.setDate(Uri.paese("tel:"+119));
startActivity(intent);

2.发短信

SmsManager smsManager=SmsManager.getDefault();
//1.一起发
smsManager.sendTextMessage("电话号码",null,"短信内容",null,null);
//2.分条发
String text="短信内容";
ArrayList<String> divide=smsManager.divideMessage(text);
for (String s:divide){
    smsManager.sendTextMessage("电话号码",null,s,null,null);
}

第八节 二种数据存储格式

一、XML解析

• 1.DOM解析

将XML文件中所有内容以DOM数形式存放在内存中，支持删除、修改等功能，缺点是消耗内存大。

• 2.SAX解析

逐行扫描XML文件，读取文件的同时即可以进行解析处理，不必等文件加载结束。缺点是无法进行增删改查

• 3.PULL解析

一个开源的JAVA项目既可以用于AndRoid应用，也可以用于JavaEE程序。Android中已经继承了PULL解析器

• 天气预报

<?xml version="1.0" encoding="utf-8"?>
    <infos>
        <city id="sh">
            <temp>20℃/30℃</temp>
            <weather>晴天多云</weather>
            <name>上海</name>
            <pm>80</pm>
            <wind>1级</wind>
        </city>
        <city id="bj">
            <temp>26℃/32℃</temp>
            <weather>晴天</weather>
            <name>北京</name>
            <pm>98</pm>
            <wind>3级</wind>
        </city>
    </infos>
</xml>

public static List<WeatherBean>getInfromXml(InputStream is)throws Exception{
    List<WeatherBean> weatherInfos=null;
    WeatherBean weatherBean=null;
    //获取pull解析器
    XmlPullParser parser=Xml.newPullParser();
    //告诉要解析的xml文件
    parser.setInput(is,"utf-8");
    //得到当前事件类型
    int type =parser.getEventType();
    //不到文件结尾 就一直解析
    while(type!=XmlPullParser.END_DOCUMENT){
        switch(type){
            case XmlPullParser.START_TAG ://解析的标签是开始标签
                if("infos".equals(parser.getName())){
                    weatherInfos =new ArrayList<WeatherBean>();
                }else if("city".equals(parser.getName())){
                    weatherBean=new weatherBean();  
                    String id= parser.getAttributeValue(0);
                    weatherBean.setId(id);
                }else if("temp".equals(parser.getName())){
                    String temp= parser.getAttributeValue(0);
                    weatherBean.settemp(temp)
                }
                break；
            case XmlPullParser.END_TAG ：
                if("city".equals(parser.getName())){
                    weatherInfos.add(weatherBean);
                }
                    break；
        }
        type=parser.next();                
    }
    return weatherInfos;
}

二、JSON数据

JSON即JavaScript Object Notation (对象表示法)，是一种轻量级的数据交换格式
JSON是基于纯文本的数据格式、可以传播String、Number、Boolean类型的数据，也可以传输数组，或者Object对象
JSON的扩展名为.json
JSON分为JSON对象和JSON数组两种数据结构

例子

{"name":"zhangsan" "address":{"city":"bejing" "postcode":100096}}
{"name":"zhangsan" "hobby":["羽毛球" "篮球"]}

JSON解析

{"name":"zhangsan","age":27,"married":true}
[16,2,26]

//解析对象
JSONObject jsonObj = new JSONObject(json1);
String name= jsonObj.optString("name");
int age =jsonObj.optInt("age");
//解析数组
JSONObject jsonObj = new JSONObject(json1);
for(int i=0;i<jsonArray.length();i++){
    int age =jsonArray.optInt(i);
}
//注意：optXXX()比getXXX方法更安全，不会抛出异常，得不到返回null或者0

2.用Gson库解析对象

//对象
Gson gson=new Gson();
Person person =gson.fromJson(json1,Person.class);
//数组
Gson gson=new Gson();
Type listType = new TypeToken<List<Integer>>(){}.getType();
List<Integer>ages =gson.fromJson(json2,listType);

················

第九节 Android中的五种数据存储方式

Android中有五种数据存储方式，它们分别是：
1.文件存储
2.SharedPreferences 存储简单配置信息(xml文件)
3.SQLiet数据库
4.ContentProvider(内容提供者) 可以将数据共享给其他应用
5.网络存储

一、文件存储的简介

• 文件存储是Android中最基本的一种存储方式，它分成两种存储类型 内部存储、外部存储

内部存储写入

String fileName="data.txt";
String content="helloworld";
FileOutput fos;
try{
    fos =openFileOutput(fileName,MODE_PRIVATE);
    fos.write(content.getBytes());
    fos.close;
}catch(Exception e){
    e.printStackTrace();
}

外部存储

String state=Environment.getExternalStorageState();
if(stare.equals(Environment.MEDIA_MOUNTED)){//判断sd卡是否可用
    File SDPath=Environment.getExternalStorageStateDirectory();
    File file=new File(SDPath,"date.text");
    String date="HelloWorld";
    FileOutputStream fos;
    try{
        fos= new FileOutputStream(file);
        fos.write(data.getBytes());
        fos.close;
    }catch(Exception e){
        e.printStackTrace();
    }

• QQ保存实战

//1.得到控件的值
String number=etText.getTex().toString().trim();//trim可以去除前后空格
//2.检查用户名密码是否为空
if(TextUtils.isEmpty(number)){}//为空返回true
//3.文件保存重新一个类
public class FileSaveQQ{
    //写入
    public static boolean save(Context context,String number，String password){
        try{
        //首先得到数据流
            FileOutputStream fos=content.openFileOutput("data.txt",content.MODE_PRIVATE);
            //把数据写到文件中
            fos.write((number+":"+password).getBytes());
            fos.close;
            return true;
        }catch(){}
    }
    //从文件中读取
    public static Map<String,String> get(Context context){
        try{
            //首先得到数据流
            FileOutputStream fis=content.openFileInput("data.txt");
            byte[] buffer=new byte[fis.available];
            fis.resd(buffer);
            Map<String,String>  userMap =new HashMap<>();
            String content=new String(buffer);
            String[] info=content.split(":");
            userMap.put("number",info[0]);
            userMap.put("password",info[1]);
            fis.close；
        }catch(){}
    }
}            
    //保存密码的数据回显
    Map<String,String> userInfo = FileSaveQQ.get(this);
    if(userInfo!=null){
        etNumber.setText(userInfo.get("number"));
        etpassword.setText(userInfo.get("password"));
    }

二、SharedPreferences

SharedPreferences是Android平台一个轻量级的存储类
用于存储配置参数、如:用户名、密码等
通过key/value(键值对)的形式将数据保存在Xml文件中
value的值，只能是float、int、long、boolean、String StringSet类型数据
使用方法
保存：

SharedPreferences sp=getSharedPreferences("data",MODE_PRIVATE);【保存成data.xml】
SharedPreferences.editor editor=sp.edit();
editor.putString("name","创智博客");
editor.putInt("age",8);
editor.commit();

获取：

SharedPreferences sp=getSharedPreferences("data",MODE_PRIVATE);
String date =sp.getString("name","");

三、SQLite数据库的操作与事务

• 1.相关简介
  SQLiet是一个轻量级数据库，占用资源非常低。在内存中只需要占用几百KB的存储空间。
  SQLiet是遵循ACID的关系型数据库管理系统，ACID是指数据库事务正确执行的四个基本要素 （原子性、一致性、隔离性、持久性）
  SQLiet保存数据时，支持NULL(零)、INTEGER(整数)、REAL(浮点数字)、TEXT(字符串文本)、BLOB(二进制对象)五种类型

• 2.创建数据库的方法
  只需要继承SQLiteOpenHelper即可

public class MyHelper extends SQLiteOpenHelper{
    public MyHelper (Context context){
        super(context,"itcast.db",null,2);//上下文、数据库文件名、游标工厂、版本
    }
    //第一次创建时候调用
    public void onCreate(SQLietDatebase db){
        db.execSQL("CREATE TABLE information(id INTEGER PRIMARY KEY AUTOINCREMENT,name VARCHAR(20),price INTEGER)");
    }
    //当实况版本号增加时候调用
    public void onUpgrade(SQLietDatebase db,int oldVersion,int newVersion){
    }
}

添加数据

public void intsert(String name,String price){
    SQLiteDatebase db=MyHelper.getWritableDatabase();
    ContentValues values= new ContentVables();
    values.put("name",name);
    values.put("price",price);
    long id =db.insert("information",null,values);//表名、sql语句不允许插入空行、表示values(固定类，底层用map实现)
    db.close();
}

修改数据

public int update(String name,String price){
    SQLiteDatebase db=MyHelper.getWritableDatabase();
    ContentVables values = new ContentValues();
    values.put("price",price);
    int number  =db.update("information",value,"name=?",new String[]{name});
    db.close();
    return number;
}

删除方法

public int delete(long id){
    SQLiteDatebase db= MyHelper.getWritableDatabas();
    int number =db.delete("information","id=?"，new String[]{id+""});
    db.close;
    return number;
}

查询方法

//cursor是一个bean类
public boolean find(long id){
    SQLiteDatebase db=MyHelper.getReadableDatebase();
    Cursor cursor=db.query("information",null,"id=?",new String[]{id+""},null,null,null);
    boolean result = cursor.moreToNext();
    cursor.close();
    db.close();
    return result;
}

查询所有

public boolean find(long id){
    SQLiteDatebase db=MyHelper.getReadableDatebase();
    Cursor cursor=db.query("information",null,null,null,null,null);
    if(cursor.getCount()==0){
        //就是说没有数据
        Toast.makeText(this,"什么都没有",Toast.LENGTH_LONG).show;
    }else{
        cursor.moveToFrist();//把第一行数据取出来
        Toast.makeText(this,cursor.getString(1),Toast.LENGTH_LONG).show;
    }
    //当然你可以这样子把所有数据都拿出来
    while(cursor.moreToNext()){
        mTvShow.append("\n"+"name"+cursor.getString(1))
    }
    cursor.close;
    db.close;
}

• 3.事务处理

PersonSQLiteOpenHelper helper= new PersonSQLiteOpenHelper(getContext());
SQLietDatebase db =helper.getWritableDatabas();
db.beginTransaction();
db.beginTransaction();
try{
    db.execSQL("update person set account =account -1000 where name = ?",new Object[]{"zhangsan"});
    db.execSQL("update person set account =account +1000 where name = ?",new Object[]{"lisi"});
    db.setTrabsactionSuccessful();
}catch(Exception E){
    Log.i("事务处理失败"，e.toString);
}finally{
    db.endTransaction();
    db.close;
}

第十节 android中的Broadcast

一、Broadcast Receiver(广播接收者)

• 1.广播接受者介绍：

1.Android系统中内置了很多广播(手机开发完成、电池电量过低都会发送)
2.为了监听来自系统或者程序的广播时间，Android通过了Broadcast Receiver组件
3.一个广播事件，可以有多个接收者处理

• 2.BroadcastReceiver的使用

1.创建BroadcastReceiver对象
2.创建好以后记得注册
3.静态注册(既是以后不开应用，系统都会帮你创建广播)

<receiver
    android:name=".MyReceiver"
    android:enabled="true"
    android:exported="true">
</receiver>

动态注册(只有应用打开的时候才接受，注意需要注销)

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    //实例化广播
    myReceiver= new MyReceiver();
    //实例化过滤器，并设置要接收的广播
    String action="android.provider.Telephony.SMS_RECEIVED";
    //创建意图过滤器对象
    IntentFilter intentFilter=new IntentFilter(action);
    registerReceiver(myReceiver,intentFilter);
}

protected void onDestroy() {
    super.onDestroy();
    //注销
    unregisterReceiver(myReceiver);
}

练习题.电话拦截器——保存电话：

SharedPreferences sp=getSharedPreferences("data",MODE_PRIVATE);
SharedPreferences.Editor editor=sp.edit();
editor.putString("name","你好");
editor.commit();
获取：
SharedPreferences sp=getSharedPreferences("data",MODE_PRIVATE);
String date =sp.getString("name","");
新的API
getResultDate();//得到电话
setResultDate(null);//修改电话

修改电话，需要在清单文件中声明

<receiver
    <intent-filter>
        <action android:name="android.intent.action.NEW_OUTGOING_CALL"></action>
    </intent-filter>
</receiver>

修改电话，涉及到打电话权限
<uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS"/>

二、自定义广播

1.当自定义广播发送消息时，会存储到公共消息区中，而公共消息区如果存在对应的广播接受者，就会及时接受到这条消息

2.拯救史迪仔

Intent intent=new Intent();
//定义广播的事件类型
intent.setAction("help_Stitch");
//发送广播
sendBroadcast(intent)

在控制台输出代码
Log.i("BroadcastReceiver","我收到了");
当然接受者要写相应的拦截器

<intent-filter>
    <action android:name="help_Stitch"></action>
</intent-filter>

三、广播的类型

1.无序广播：完全异步执行，发送广播时所有监听该广播的接收者会同时收到消息

    Intent intent=new Intent();
    intent.setAction("help_Stitch");
    intent.putExtra("data","鬼子进村了")；
    sendBroadcast(intent);

2.有序广播：安装接收者的优先级，只有一个广播接收后，执行完相应逻辑，才会继续传播。(可以被拦截)
优先级设定:

<receiver>
    <intent-filter 
        android:name=""
        android:priority="" //值越大，优先级越高（相同级别，先创建先收到）
    >
</receiver>

发送广播

Intent intent=new Intent();
//定义广播的事件类型
intent.setAction("help_Stitch");
//发送广播
sendOrderedBroadcast(intent,null);//第二个是权限，不需要则设置为null

接收广播

• 拦截
  abortBroadcast();
• 修改
  setResultData("上面发了500斤大米");
• 得到数据
  getResultData()

3.写入一定会被某个接收者的广播

sendOrderedBroadcast(intent,null,new final(),null,0,"发1000斤大米",null);
//myReceiver即使等级很低，即使被拦截，依然会被final接收（final不需要配置）

四、广播打开activity

Intent intent=new Intent(this,Activity2.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
content.startActivity(intent);

第十一节 android中的server

startService一旦开启就要手动关闭，而bingService()与Actity组件绑定 不求同年同月同日但求同年同月同日死

一、服务的创建

• 1.服务可以看做是一个没有界面的Activity。比如音乐的播放

特点：在后台长期运行

• 2.服务的创建

二、服务的声明周期

• 1.和activity一样创建与销毁
• 2.服务的开启方式有两种

(1)通过startService()方式启动

通过startService()方式启动，需要自身调用stopSelf()方法或其他组件调用stopService()方法服务才能停止
onCreate()-》onStartCommand()-》Service running-》上面-》onDestroy()

(2)通过bindService()方式启动

通过bindService()方式启动，需要调用onUnbind方法解除绑定才能销毁
onCreate()-》onBind()-》Service running-》上面-》onDestroy()

三、服务的启动方式

案例1.
通过startService：特点：与开启者没有关系。既是启动组件被销毁，服务依然运行。
onStartCommand()可以执行多次
需要在Service中写onCreate()、onStartCommand()、onDestroy()方法; onBind()不用，返回null

//开启：
Intent intent =new Intent(this,MyServer.class);
startService(intent);
//关闭：
Intent intent =new Intent(this,MyServer.class);
stopService(intent);

案例2.
通过bingService()
需要在Service中写onCreate()、onUnbind()方法；||onBind()方法绑定(返回一个IBinder数据类型)、onUnbind()解绑 onBind()不能多次执行
需一个内部类继承Binder(已经实现了IBinder接口)
//通过该对象可以间接的访问服务(在里面可以调用该服务的方法)
class MyBinder extends Binder{
}
//IBinder是夸进程访问

开启：
bindServer(intent,conn,flags);||//意图(指明要开启哪一个)，ServiceConnection用于监听调用者与service的连接状态，指明连接时是否自动创建service
成员变量MyConn myconn;
在某个方法内

{
    if(myconn==null){
        myconn=new MyConn();
    }
    Intent intent =new Intent(this,MyServer.class);
    bindServer(intent,myconn,BIND_ABOVE_CLIENT);
}
//在Activity中创建一个内部类
private class MyConn implements ServiceConnection{
//当服务连接的时候，调用该方法，
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
    MyService.MyBinder myBinder=(MyService.MyBinder)iBinder;
    log.i("MainActivity","服务成功绑定")
}
//当服务失去连接的时候调用该方法
public void onServiceDisconnected(ComponentName componentName) {
}
         
//关闭:用onUnbind
if(myconn!=null){
    unbindService(myconn);
    myconn==null
}

四、通信方式

本地通信（运行在自己应用的服务）
远程服务通信(运行在其他应用的服务)【AIDL】
android interface Definition language；

• 1.先把interface 文件后缀改成aidl[Stub使用进程间通信IPC]
• 2.服务类中间人mybind直接继承stub
• 3.在本地创建一个一模一样的包 一模一样的.aidl文件
• 4.在获取的时候不使用iservice=(Iservice)iBinder;而是 iservice=stub.asInterface(server);

五、音乐播放器

MediaPlayer mediaPlayer=new MediaPlayer();
//指定音频文件
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
mediaPlayer.setDataSource("dizhi");
mediaPlayer.prepare();//准备播
mediaPlayer.start();//开始播
if(mediaPlayer.isplaying())//判断在不在播放
mediaPlayer.stop;
mediaPlayer.release();
mediaPlayer=null;

六、进程概念【一个进程含有多个线程】

四大组件都运行在主线程中（换句话说 四大组件都运行在主线程中）
系统尽可能长时间的维持进程的操作，
五种进程的优先级

• 1.前台进程(正在调用onResum()方法)
• 2.可视进程(用户可见，影响用户看得见)
• 3.服务进程(通过通过startService()方式启动)【一般不会杀到这里】
• 4.后台进程(activity进行了onstop()方法)
• 5.空进程(不维持任何激活组件)[有时不杀死，提高速度]

七、通过特定的接口 暴露想暴露的方法

• 1.定义一个接口 把自己想暴露的方法暴露在接口中
• 2.定义的中间人实现接口
• 3.在获取中间人对象时mybinder

八、混合方式开启服务(既想长期运行 又想调用里面的方法)

startserver让服务运行
在服务类中创建中间人mybind继承Binder
mybind方法实现接口类
服务类onBind方法返回刚才创建的类
在actity中创建myconn实现ServiceConnection类 然后new出来
然后bindService(intent,myconn,BIND_AUTO_CREATE);
调用unbindserver解绑服务

第十二节 android中的内容提供者contentProvider

一、内容提供者(contentProvider)

内容提供者是android的四大组件之一，它是不同应用程序之间进行数据共享的标准API
ContentResolver类可以访问ContentPrivider中共享数据
他们主要是通过ContentProvider 与ContentResolver两个组件

• 1.ContentResolver提供了一系列的增删改查方法对数据进行操作，并将这些方法以uri的形式对外通过数据
• 2.uri为内容提供者中的数据建立了唯一标识符。主要由3部分构成

1.scheme部分：content：//是标准前缀，不能被修改
2.authority部分：创建内容提供者指定的authorities属性值，通常采用程序包名的方式命名
3.path部分：/person 代表资源或数据，可以动态改变

例：content://cn.itcast.mycontentprovider/person

二、内容提供者的创建{在日志中搜索Pub}

创建：
new->Other->Content Provider
URI Authorities 通过哪一个uri可以访问该内容提供者 (一般用包名 cn.itcast.mycontentprovider)
Exported：是否暴露给别人
Enabled：是否允许系统自动创建
其中几个方法
getType：获取媒体类型
需要在清单文件中声明
例子：(这里以查询为例)

public class MyContentProvider extends ContentProvider {
    private static final UriMatcher sUriMatcher=new UriMatcher(UriMatcher.NO_MATCH);//不匹配返回-1
    private static final int QUERYSUCCSEE=0;
    private static final int INSERTSUCCSEE=1;
    private MyHelper myHelper;
    public MyContentProvider() {
        sUriMatcher.addURI("henan.com.provider","query",QUERYSUCCSEE);
        sUriMatcher.addURI("henan.com.provider","insert",INSERTSUCCSEE);
    }
    
    @Override
    public boolean onCreate() {
        myHelper = new MyHelper(getContext());
        return false;
    }
    
    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    
    @Override
    public String getType(Uri uri) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        int code = sUriMatcher.match(uri);
        if (code==INSERTSUCCSEE){
            SQLiteDatabase myDatabase = myHelper.getReadableDatabase();
            long insert=myDatabase.insert("info",null,values);
            Uri uri1=Uri.parse("com.henan.insert/"+insert);
            return uri1;
        }else {
            return null;
        }
    }

    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        int code = sUriMatcher.match(uri);
        if (code==QUERYSUCCSEE){
            SQLiteDatabase myDatabase = myHelper.getReadableDatabase();
            Cursor query = myDatabase.query("info", projection, selection, selectionArgs, null, null, sortOrder);
            myDatabase.close()
            //这里cursor不用关,但是数据库要关
            return query;
        }else {
            return null;
        }
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
}

三、内容解析者

查询

Uri uri = Uri.parse("content://henan.com.provider/query");
ContentResolver contentResolver= getContentResolver();//获取ContentResolver对象
Cursor cursor=contentResolver.query(uri,new String[]{"name","age"},null,null,null);//条件、条件参数、排序
while (cursor.moveToNext()){
    String name=cursor.getString(1);
    int age=cursor.getInt(2);
}
cursor.close();

插入

Uri uri = Uri.parse("content://henan.com.provider/insert");
ContentValues contentValues=new ContentValues();
contentValues.put("name","张三");
contentValues.put("password","123");
ContentResolver contentResolver= getContentResolver();//获取ContentResolver对象
Uri uri=contentResolver.insert(uri,contentValues);

四、查看短信案例

五、内容观察者ContentObserver

1.内容观察者是用来指定Uri所代表的数据。当ContentObserver观察到指定Uri代表的数据发生变化时，就会触发onChange()方法，在该方法中使用ContentProvider可查询数据变化
2.要使用ContentObserver观察数据变化，就必须在ContentProvider的delete()、insert()、update()方法中调用ContentResover的notifyChange()方法;
假设B程序调用A程序

/*
 *A程序：ContentProvider暴露数据并调用ContentResolver的notifyChange()方法
 *      当程序发生变化是，A向信息中心发生消息
 *B程序：使用ContentResolver操作A程序的数据
 *C程序：注册ContentObserver
 *     观察消息中心的消息，通过消息观察A程序的数据变化
 *     当观察到变化的数据触发onChange()方法
 */

//ContentObserver的两个常用方法：
public ContentObserver(Handler handler){}
//ContentObserver的派生类都需要调用该构造方法，参数可以是主线程Handler，也可以是其他handler对象
public void onChange(boolean selfChange){}
//当观察者Uri代表的数据发生变化时，会触发该方法。在该方法中使用ContentResovler可以查询到变化数据
Uri uri = Uri.parse("content://cn.itcast.mycontentprovider/person");//一定要注意首字母大写其余小写
ContentResolver contentResolver= getContentResolver();//获取ContentResolver对象
contentResolver.registerContentObserver(uri,true,MyObserver(new Handler()));//第二个参数：是否精确匹配uri true只匹配该uri false匹配其派生类 第三个参数：ContentObserver实例 

六、常用的几个系统表

data表：datal存所有人联系的信息 mimetype_id区分是什么信息 raw_contact_id:存放有多少条信息
raw_contacts：mimetype表

第十三节 初步http协议

一、http协议：

超文本传输协议

二、HttpURLConnection的基本用法

URL url=new URL("http://www.itcast.cn");
HttpURLConnection conn=(HttpURLConnection)url.openConnection();
conn.setRequestMethod("GET");
conn.setConnectTimeout(5000);//连接超时时间
InputStream is=conn.getInputStream();
conn.disconnect();

三、GET和POST请求方式

String path = "http://xx.xxx.xx.xxx:80/web/LoginServlet?username="+URLEncoder.encode("zhangsan")+"&password="+URLEncoder.encode("123");
URL url=new URL(path);
HttpURLConnection conn=(HttpURLConnection)url.openConnection();

第十四节 多线程初步

一、多线程编程

android的主线程不能进行耗时操作（4.0以后强制，主线程也没这个义务）
打印线程名称方法：
Thread.currentThread().getName();(Android的主线程就是UI线程,只有UI线程才可以更新ui)

开启多线程的方法一：

第一步：new Thread(){}
第二步：new Thread(){}.stare()
第三步：new Thread(){public void run(){};}.stare()

开启多线程的方法二：(基本上用第一种,第二种是在特殊方法中使用)

new Runnable(){}
new Runnable(){public void run(){};}

二、handle机制

主线程 含handler，可以告诉系统更新ui
handler的作用是发消息和处理消息
looper是从消息队列里取消息
(该模型十分重要)

1.以下是更新ui的方法(该方法小白使用，存在内存泄漏风险)

Handler handler=new Handler(){
//该方法在UI线程执行
    @Override
    public void handleMessage(Message msg) {
        String s=(String)msg.obj;
        view.setText(s);
    }
}

new Thread(){
    @Override
    public void run() {
        Message msg=new Message();
        String content="内容";
        msg.obj=content;
        handler.sendMessage(msg);//发送一条消息，数据放到msg里（子线程）handleMessage方法便会执行
    }
}.start();

图片查看器

new Thread(){
    try{
        //获取访问图片路径
        String path=et_view.getText().toString().trim();
        //创建URL路径
        URL url=new URL(path);
        //获取httpurlconnection
        HttpURLConnection  conn=(HttpURLConnection)url.openConnection();
        //设置请求方式
        conn.setRequestMethod("GET");
        //设置超时时间
        conn.setConnectTimeout(5000)
        //获取服务器返回状态码
        int code=conn.getResponseCode();
        if(code == 200){//200代表成功 404代表没有找到
            //获取图片数据(基本上都是以流的形式接收)
            InputStream in=conn.getInputStream();
            //通过位图工厂获取位图
            Bitmap bitmap=BitmapFactory.decodeStream(in);
            //把位图显示到iv上
            Message msg= Message.obtain();//使用msg的静态方法 可以减少对对象的创建
            msg.obj=bitmap;
            handler.sendMessage(msg)；
         }
    }
}.start();

三、缓存机制

//缓存图片，谷歌给我们提供了一个缓存目录getCacheDir() //创建缓存目录[类似于 getFilesDir()//创建file目录]
File file=new File(getCacheDir(),"Beautiful.png")
if(file.exists()&&file.length()>0){
    Bitmap cacheBitmap=BitmapFactory.decodeFile(file.getAbsolutePath());//
    Message msg=Message.obtain();
    msg.obj=cacheBitmap;
    handler.sendMessage(msg)
}else{
    //第一次
}

四、cache目录和filedir目录区别

cache可以被用户手动清除掉缓存(用户可以清楚)
file可以被用户手动清除掉data

五、runOnUiThread();

作用：在主线程中会立即执行 在子线程中会交给主线程执行

runOnUiThread(new Runnable(){
    @Override
    public void run() {
        view.setText("xxx");
    }
});

六、常见的API

下面的方法不能更新ui(当然可以用runOnUiThread())【大部分在企业中是没办法用的，有兴趣的同学可以学习线程池】
第一个：handler

//2秒后执行run方法
new Handler().postDelayed(new Runnable(){
    public void run(){
        syso("哈哈哈")
    }
},2000)

第二个：time

//5秒后进行run方法
Timer timer =new Timer();
TimerTask task=new TimerTask(){
   public void run(){
       syso("呵呵呵")
   }
};
timer.schedule(task,5000)[也可以是timer.schedule(task,5000,1000)]
     
//销毁方法
timer.cancel();
task.cancel();

七、将字符流转换成string的方法

public String inputStream2String(InputStream is)   throws IOException{
    BufferedReader reader = new BufferedReader(new InputStreamReader(is));
    StringBuilder sb = new StringBuilder();
    String line = null;
    try {
        while ((line = reader.readLine()) != null) {
            sb.append(line + "\n");
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return sb.toString();
}

八、服务器的逻辑

public void androidlogin() {
/*使用servletActionContext对象拿request与Response都很简单*/
HttpServletRequest request=ServletActionContext.getRequest();
String phone=request.getParameter("phone");
String password=request.getParameter("password");
System.out.println(phone);
HttpServletResponse response=ServletActionContext.getResponse();
response.setContentType("text/plain; charset=utf-8");
PrintWriter out;
try {
    out = response.getWriter();
    out.print("登录成功");
    out.flush();
        out.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

九、HttpURLConnection的get与post客户端逻辑

public void click1(View view) {
    String name=name_edit.getText().toString().trim();
    String password=password_edit.getText().toString().trim();
    final String path="http://117.34.240.61:8080/AndroidServiceDome2/user_androidlogin.action?phone="+name+"&password="+password;
    new Thread(){
        @Override
        public void run() {
            try{
                URL url=new URL(path);
                HttpURLConnection conn=(HttpURLConnection)url.openConnection();
                conn.setRequestMethod("GET");
                conn.setConnectTimeout(5000);
                int code=conn.getResponseCode();
                if(code == 200) {//200代表成功 404代表没有找到
                    InputStream inputStream = conn.getInputStream();
                    Util util=new Util();
                    String S =util.inputStream2String(inputStream);
                    //因為不可以在子線程展示ui所以
                    showToast(S);
                }
            }catch (Exception e){
            }
        }
    }.start();
}

public void click2(View view) {
    final String name=name_edit.getText().toString().trim();
    final String password=password_edit.getText().toString().trim();
    final String path="http://117.34.240.61:8080/AndroidServiceDome2/user_androidlogin.action";
    new Thread(){
        @Override
        public void run() {
            try{
                String data="phone="+name+"&password="+password;
                URL url=new URL(path);
                HttpURLConnection conn=(HttpURLConnection)url.openConnection();
                conn.setRequestMethod("POST");
                conn.setConnectTimeout(5000);
                conn.setRequestProperty("Content-Type","application/x-www-form-urlencoded");
                conn.setRequestProperty("Content-Length",data.length()+"");
                conn.setDoOutput(true);
                conn.getOutputStream().write(data.getBytes());
                int code=conn.getResponseCode();
                if(code == 200) {//200代表成功 404代表没有找到
                    InputStream inputStream = conn.getInputStream();
                    Util util=new Util();
                    String S =util.inputStream2String(inputStream);
                    //因為不可以在子線程展示ui所以
                    showToast(S);
                }
            }catch (Exception e){
            }
        }
    }.start();
}

十、httpclient（使用直接子类Defaulthttpcliet）【该方法已经过时】

DefaultHttpClient client = new DefaultHttpClient();
HttpGet get = new HttpGet(path);
HttpResponse response = client.execute(get);
int code = response.getStatusLine().getStatusCode();
if(code == 200){
    InputStream inputStream=response.getEntity().getContent();
    showToast(content);
}
DefaultHttpClient client = new DefaultHttpClient();
HttpPost post = new HttpPost(path);
List<NameValuePair> lists= new ArrayList<NameValuePair>();
BasicNameValuePair nameValuePair = new BasicNameValuePair("phone",name);
BasicNameValuePair passwordValuePair = new BasicNameValuePair("password",password);
lists.add(nameValuePair);
lists.add(passwordValuePair);
URLEncodedFormEntity entity = new URLEncodedFormEntity(lists);
post.setEntity(entity);
HttpResponse response = client.execute(post);
int code = response.getStatusLine().getStatusCode();
if(code == 200){
    InputStream inputStream=response.getEntity().getContent();
    showToast(content);
}

十一、retrofit

下载包

//retrofit
compile 'com.squareup.retrofit2:retrofit:2.1.0'　
compile 'com.squareup.retrofit2:converter-gson:2.1.0'

十二、多线程加速下载

1.注意

• 不是线程越多下载越快
• 下载速度受服务器带宽的影响

2.多线程下载步骤
[1]获取文件大小

int length=conn.getContentLength()//得到字节长度
runningThread = threadCount;

[2]在客户端创建一个大小和服务器一模一样的文件提前申请好空间

RandomAccessFile rafAccessFile = new RandomAccessFile("dome.exe","rw");
rafAccessFile.setLength(length);
//[2.1]确定每个线程下载的开始位置与结束位置
int blockSize =length/threadCount;//提前声明好有几个线程
for(int i=0; i<theadCount;i++){
    int startIndex = i*blockSize;
    int endIndex=(i+1)*blockSize-1;
    if(i==threadCount-1){
        endIndex=length-1;
        syso("线程"+i+"理论下载的位置"+startIndex+"-----"+endIndex)
        //开启线程
        DownLoadThread  downLoadThread = new DownLoadThread（startIndex,endIndex,i）;
        downLoadThread.start();
     }
}

[3]开多个线程去下载文件

//这里单独抽取一下
private static class DownLoadThread extends Thread{
    private int startIndex;
    private int endIndex;
    private int threadId;
    
    public DownLoadThread (int startIndex,int endIndex,int threadId){
        this.startIndex=startIndex;
        this.endIndex=endIndex;
        this.threadId=threadId;
    }
    
    public void run(){
        try{
            URL url=new URL(path);
            HttpURLConnection conn=(HttpURLConnection)url.openConnection();
            conn.setRequestMethod("GET");
            conn.setConnectTimeout(5000);
                            
            //再次下载要先看看上一次是不是没下完、
            File file =new File(threadId+".txt")
            if(file.exists()&&file.length()>0){
                FileInputStream fis =new FileInputStream(file);
                BufferedReader bufr =new BufferedReader(new InputStreamReader(fis));
                String lastPositionn=bufr.readLine();
                int lastPosition=Integer.parseInt(lastPositionn);
                startIndex=lastPosition;
                syso("线程"+threadId+"真实下载的位置"+startIndex+"-----"+endIndex)
                fis.close;
             }
             //[3.1]设置一个请求头Range
             conn.setRequestProperty("Range","bytes="+startIndex+"-"+endIndex);
             int code=conn.getResponseCode();
             if(code == 200) {//200代表成功 404代表没有找到
                //创建随机文件读写对象
                RandomAccessFile raf = new RandomAccessFile("dome.exe","rw");
                ref.seek(startIndex);
                InputStream inputStream = conn.getInputStream();
                //把内容写到文件中
                int len=-1；
                /*****断点续传(把当前进度用文件存起来)****/
                int total=0；//代表当前下载的大小
                byte[] buffer=new byte[2014*1024];//定义缓冲区的大小
                while((len = in.read(buffer))!=-1){
                    raf.write(buffer,0,len);
                    total +=len；
                    int currentThreadPosition=startIndex+total；
                    /*该方式不安全*/
                    //File file = new File(threadId+".txt")
                    //FileOutputStream fos = new FileOutputStream(file);
                    //fos.write(String.valueOf(currentThreadPosition).getBytes());
                    //fos.close；
                    RandomAccessFile raff =new RandomAccessFile(threadId+".txt","rws");raff.write(String.valueOf(currentThreadPosition).getBytes());
                    raff.close;
                }
            raf.close();
            syso("线程id："+threadId+"加载完毕")
            //把txt文件删除（之前声明一个runningThread 代表当前正在运行的线程）
            synchronized(DownLoadThread.class){//线程锁
                runningThread--;
                if(runningThread==0){
                //说明执行完毕
                    for(int i=0;i<threadCount;i++){
                        File deletFile=new File(i+".txt");
                        delteFile.delete();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }    
    }
    public static String getFilenam(String path){
        int start =path.lastIndexOf("/")+1;
        return path.substring(start);
    }
}

[4]知道每个线程什么时候下载完毕将文件拼接起来即可

第十五节 多媒体初步

一、计算机表示图形的几种方式

bmp：以高质量保存
jpg：以良好质量保存
png：以高质量保存(png与jpg差不多 只不过压缩算法不一样，png压缩算法更好)
图片大小的计算公式：（图片总像素 X 每一个像素的大小）
单色： 只有两种颜色(要么是黑要么是白) 每一个像素只要长度是1的二进制位表示(一个像素占1/8个byte)
16色： 每个像素最多可以表示16种颜色 0000-1111 只需要使用长度为4的二进制表示(一个像素占1/2个byte)
256色： 每个像素最多可以表示256种颜色 0000 0000-1111 1111 只需要使用长度为8的二进制表示(一个像素占1个byte)
24位： 每个像素最多可以表示1600万种颜色 RGB组合 一个像素占3byte(RGB各占一个byte)
在android中采用png，采用的是arpg一个像素四个byte

二、缩放加载大图片

Bitmap bitmap=BitmapFactory.decodeFile("/mnt/sdcard/dog.jpg")
imageView.setImageBitmap()

(oom内存溢出异常,因为默认给每个应用就分配16m空间，而图片加载申请内存与图片大小有关 与真实大小无关)

正确方法:

• 1.获取图片分辨
• 2.获取手机分辨率
• 3.计算缩放比(宽除以宽，高除以高，然后按照大的缩放)

//获取手机宽与高
WindowManager wm = (WindowManager)getSystemService(WINDOW_SERVICE);
//第一种过时
int height = wm.getDefaultDisplay().getHeight();
int width = wm.getDefaultDisplay().getWidth();
//第二种
Point point = new Point();
wm.getDefaultDisplay().getSize(point);
int height1 = point.x;
int width1 = point.y;
//加载图片信息
//创建一个位图工厂创建一个参数
BitmapFactory.Options options=new BitmapFactory.Options();
//解码器不去真正的解析位图 但是还能够获取图片的宽与高信息
options.inJustDecodeBounds =true;
BitmapFactory.decodeFile("/mnt/sdcard/dog.jpg",options);
int imgw=options.outWidth;
int imgh=options.outHeight;
//计算缩放比
int scale=(imgw/height)>=(imgh/height)?(imgw/height):(imgh/height);
//但是不能小于1
if (scale<1){
        scale=1;
}
options.inSampleSize=scale;
//加载图片
options.inJustDecodeBounds =false;
Bitmap bitmap = BitmapFactory.decodeFile("/mnt/sdcard/dog.jpg", options);
                imageView.setImageBitmap(bitmap);

三、创建原图副本

//把普通照片转化成bitmap
Bitmap srcBitmap=BitmapFactory.decodeResource(getResources(),R.drawable.ic_launcher_background);
//创建了一个与原图一样的空白的白纸
Bitmap copyBitmap = Bitmap.createBitmap(srcBitmap.getWidth(), srcBitmap.getHeight(), srcBitmap.getConfig());
//用画笔画一个与原图一样的图
//1.拿画笔
Paint paint=new Paint();
//2.拿画布并把把画布铺在copy图上
Canvas canvas=new Canvas(copyBitmap);
//3.画图
canvas.drawBitmap(srcBitmap,new Matrix(),paint);
//已经画好的图修改(一次修改一个像素)
copyBitmap.setPixel(20,20, Color.BLUE);

四、图形处理的api

旋转

//1.拿画笔
Paint paint=new Paint();
//2.拿画布并把把画布铺在copy图上
Canvas canvas=new Canvas(copyBitmap);
Matrix matrix = new Matrix();
//旋转角度,基于什么中心点           matrix.setRotate(20,copyBitmap.getWidth()/2,copyBitmap.getHeight()/2);
canvas.drawBitmap(srcBitmap,matrix,paint);

缩放

//缩放比例（水平，竖直）
matrix.setScale(0.5f,0.4f);

平移

//水平，竖直
matrix.setTranslate(30,0);

镜面(旋转平移组合)

matrix.setScale(-1f,0);
//使用post是在修改的基础上修改
matrix.postTranslate(copyBitmap.getWidth(),0);

倒影

matrix.setScale(1f,-1f);
matrix.postTranslate(0,copyBitmap.getHeight());

五、使用mediaplayer播放音频文件(mediaPlayer只能播放mp4或者3gp格式)

MediaPlayer mediaPlayer=new MediaPlayer();
try {
    mediaPlayer.setDataSource("/mnt/sdcard/dog.mp3");
    mediaPlayer.prepare();
    mediaPlayer.start();
} catch (IOException e) {
    e.printStackTrace();
}
mediaPlayer.stop();

六、surfaceview介绍(控件)

他是一个重量级控件
维护两个线程A、加载数据 B、显示数据 可以直接更新ui

View scroll = findViewById(R.id.scrollView1);
SurfaceHolder handler = (SurfaceHolder)scroll.getHandler();
MediaPlayer mediaPlayer = new MediaPlayer();
try {
    mediaPlayer.setDataSource("/mnt/sdcard/dog.mp4");
    mediaPlayer.prepareAsync();
    mediaPlayer.setDisplay(handler);
    mediaPlayer.start();
} catch (IOException e) {
    e.printStackTrace();
}

七、VideoView控件介绍

VideoView videoView = findViewById(R.id.video_view);
videoView.setVideoPath("/mnt/sdcard/dog.mp4");
videoView.start();

八、vitamio框架

九、照相与录像

第十六节 Fragment入门

一、fragment入门 [最低11版本(即3.0)]

它总是被嵌入到activity当中，生命周期被activity影响

• 1.ViewGroup可以有自己的孩子
• 2.view 没有自己的孩子

通过 onCreateView这个方法可以加载fragmen自己的布局
第一种加载fragment方式

<fragment
    android:layout_width="0dp"
    android:layout_weight="1"
    android:layout_height="match_parent"
    android:id="@+id/addfragment_first"
    android:name="dome813.henan.com.fragmentdome.Fragment1"
/>
<fragment
    android:layout_width="0dp"
    android:layout_weight="1"
    android:layout_height="match_parent"
    android:id="@+id/addfragment_second"
    android:name="dome813.henan.com.fragmentdome.Fragment2"
/>

public class Fragment2 extends Fragment {
    //第一次调UI的时候执行该方法 加载fragment自己的控件
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, Bundle savedInstanceState) {
    //通过打气筒将布局转化成view
        View view = inflater.inflate(R.layout.fragmentlayout2,null);
        return view;
    }
}

第二种加载fragment方式(动态加载)

FragmentManager fragmentManager = getFragmentManager();
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
String state = null;
if (state=="横屏"){
    fragmentTransaction.replace(android.R.id.content,new Fragment1());
}else{
    fragmentTransaction.replace(android.R.id.content,new Fragment2());
}
fragmentTransaction.commit();

3.fragment的xml中 不能用onClick方法点击，只能通过id方式 setOnClickListener
4.兼容11版本以下的 就要使V4包

二、fragment的生命周期

onAttach()
    onCreate()
        onCreateView()//第一次画ui 必须重新
            onActivityCreated()//准备view 已初始化
                onStart()
                    onResum()
                    onPause()
                onStop()
        onDestroyView()
    onDestroy()//回收内存
onDetach

三、fragment之间的通信 （通过activity）

public class Fragment1 extends Fragment {
    //第一次调UI的时候执行该方法 加载fragment自己的控件
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, Bundle savedInstanceState) {
    //通过打气筒将布局转化成view
        View view = inflater.inflate(R.layout.fragmentlayout1,null);
        view.findViewById(R.id.button1).setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            Fragment2 fragment2 =(Fragment2)getActivity().getFragmentManager().findFragmentByTag("massage1");
         }
    });
    return view;
    }
}
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
    .....
        if (state=="横屏"){
            fragmentTransaction.replace(android.R.id.content,new Fragment1(),"message1");
        else{
            fragmentTransaction.replace(android.R.id.content,new Fragment2(),"message2");
        }
        fragmentTransaction.commit();
    }
}