项目5记忆的仓库——备忘录
【教学导航】





学习目标
(1) 了解SharedPreferences实现简单的数据存储方法。

(2) 理解Android中的文件存储方法。

(3) 掌握摄像头调用和相册获取图片的方法。

(4) 了解Android运行时权限设置。

(5) 具备较复杂案例的设计开发能力。
教学方法任务驱动法、理论实践一体化、探究学习法、分组讨论法
课时建议
8课时


5.1SharedPreferences存储
Android中常用的三大存储方式分别是SharedPreferences存储、文件存储和数据库存储。其中，SharedPreferences存储在程序中有少量的数据需要保存时使用，它存储数据的格式很简单，采用键值对的方式来存储数据。文件存储主要用来存储资源文件，如一篇日记、一首歌等。数据库存储常用于当程序中有大量数据需要存储、访问时，就需要借助于数据库，Android内置了SQLite数据库。本节将针对SharedPreferences存储进行讲解。



微课视频


5.1.1SharedPreferences简介
SharedPreferences是Android平台上一个轻量级的存储类，常用于存储一些应用程序的配置参数，例如用户名、密码、是否打开同步、是否打开音响、自定义参数的设置等。SharedPreferences中存储的数据是以keyvalue（键值）对的形式保存在XML文件中，需要注意的是，SharedPreferences中的value值只能是float、int、long、boolean、String、StringSet类型数据。
1. SharedPreferences常用方法
SharedPreferences提供了一系列的方法用于获取应用程序中的数据，具体如表5.1所示。



表5.1SharedPreferences常用方法



属性功能描述实例
getSharedPreferences(String name,String mode)获取SharedPreference的实例对象
SharedPreference sp=this.getSharedPreferences("myinfo",0)
getString(String key,String defValue)
获取SharedPreferences中指定的key对应的String值
getSharedPreferences("myinfo",0).getString("name","");
getInt(String key,int defValue)
获取SharedPreferences中指定的key对应的int值
getSharedPreferences("myinfo",0).getInt("age",0);
getBoolean(String key,boolean defValue)
获取SharedPreferences中指定的key对应的boolean值
getSharedPreferences("info",0).getBoolean("married",false);
getFloat(String key,float defValue)
获取SharedPreferences中指定的key对应的float值
getSharedPreferences("info",0).getFloat("weight",0);
getLong(String key,long defValue)
获取SharedPreferences中指定的key对应的long值
getSharedPreferences("info",0).getLong("birthdistance",0);

表5.1中，使用SharedPreferences类存储数据时，首先需要通过context. getSharedPreferences(String name,

int mode)获取SharedPreferences的实例对象，其中context表示上下文环境，在Activity中可以直接使用this代表上下文，如果不是在Activity中则需要传入一个Context对象获取上下文。



getSharedPreferences(String name,String mode)方法中，第一个参数name表示文件名，如果指定的文件不存在则会创建一个新文件，该文件存放在data/data/<package name>/shared_prefs目录下。第二个参数mode用于指定文件操作模式，目前只有MODE_PRIVATE这一种模式可选，指定该SharedPreferences数据只能被本应用程序读写，它是默认的操作模式，和直接传入0效果是相同的，其他几种模式从Android 4.2版本开始均已废弃。
getXxx(String,xxx value)获取SharedPreferences数据里指定key对应的value。如果该key不存在，则返回默认值value。其中，xxx可以是boolean、float、int、long、String等多种基本类型。





2. SharedPreferences.Editor常用方法
SharedPreferences对象本身只能获取数据，并不支持数据的存储和修改，数据的存储和修改需要通过SharedPreferences.Editor对象来实现。要想获取Edit实例对象，需要调用SharedPreferences.Editor的edit()方法，Editor提供一系列方法来向SharedPreferences写入数据，如表5.2所示。


表5.2SharedPreferences.Editor常用方法



方法功能描述实例
SharedPreferences.Editor edit()创建一个Editor对象SharedPreferences.Editor editor=this.
getSharedPreferences("myinfo",0).edit();
SharedPreferences.Editor putString(String key,String value)
向SharedPreferences中存入指定key对应的String 值
editor.putString("name","张三");
SharedPreferences.Editor putInt(String key,int value)
向SharedPreferences中存入指定key对应的int值
editor.putInt("age",20);
SharedPreferences.Editor putBoolean(String key,boolean value)
向SharedPreferences中存入指定key对应的boolean值
editor.putBoolean("married",false);
SharedPreferences.Editor putFloat(String key,float value)
向SharedPreferences中存入指定key对应的float值
editor.putFloat("weight",76.5f); （其中，f表示float）
SharedPreferences.Editor putLong(String key,long value)
向SharedPreferences中存入指定key对应的long值
editor.putLong("birthdistance",154672920439l); （其中，l表示long）
SharedPreferences.Editor remove(String key)
删除SharedPreferences中指定key对应的数据
editor.remove("weight");
boolean commit()
提交数据，返回boolean表明提交是否成功
editor.commit();
SharedPreferences.Editor apply()
提交数据，没有返回值
editor.apply();
SharedPreferences.Editor clear()
清除SharedPreferences中的所有数据
SharedPreferences.Editor editor1=getSharedPreferences("myinfo",0).edit();

editor1.clear();

editor1.commit();




微课视频


5.1.2SharedPreferences的使用
1. 将数据存储到SharedPreferences中

使用SharedPreferences存储数据时，需要先获取SharedPreferences对象，通过该对象的edit()方法获取到Editor对象，然后通过Editor对象的相关方法存储数据，具体代码如下。



SharedPreferences.Editor editor=getSharedPreferences("myinfo",0).edit();   //获取编辑器editor

editor.putString("name","张三"); 	 			 //存入String类型数据

editor.putInt("age",20);   					 //存入int类型数

editor.putBoolean("married",false);			 //存入boolean类型数据

editor.putFloat("weight",76.8f);   			 //存入float类型数据

editor.putLong("birthdistance",154672920439l);  //存入long类型数据

editor.commit();						　　//提交数据，保存成功


2. 从SharedPreferences中读取数据
SharedPreferences获取数据比较简单，只需要创建SharedPreferences对象，然后使用该对象获取相应key的值即可。具体代码如下。



String myname=getSharedPreferences("myinfo",0).getString("name","");		     //获取用户名

int myage=getSharedPreferences("myinfo",0).getInt("age",0);					 //获取年龄

float weight=getSharedPreferences("info",0).getFloat("weight",0); 				 //获取体重

boolean mymarried=getSharedPreferences("info",0).getBoolean("married",false);   
//获取婚姻状态

long mybirthdistance=getSharedPreferences("info",0).getLong("birthdistance",0);   
//获取出生到现在的时长


3. 删除SharedPreferences中的数据
SharedPreferences删除数据与存储数据类似，同样需要先获取到Editor对象，然后通过该对象删除数据，最后提交，具体代码如下。



SharedPreferences.Editor editor1=getSharedPreferences("myinfo",0).edit();  
//获取编辑器对象，取名为editor1

editor1.remove("name");    			  //删除一条数据

editor1.clear();							  //删除所有数据

editor1.commit();				 		  //提交数据，保存成功


SharedPreferences使用很简单，但一定要注意以下两点。
(1) 存入数据和删除数据时，一定要在最后使用editor.commit()方法提交数据。
(2) 读取数据的key值与存入数据的key值的数据类型要一致，否则查找不到数据。
4. SharedPreferences案例
1) 案例分析
(1) 界面分析。布局界面中有5个控件，其中两个EditText控件用于输入用户名和密码，复选框CheckBox供用户选择是否需要记住密码，“登录”按钮保存信息并跳转到第二个页面。
(2) 设计思路。布局界面中的控件通过添加属性的方式达到用户需求，在登录按钮单击事件内部实现用户名、密码、复选框状态等数据的存储，下次启动App时，根据复选框的状态决定是否显示存储的用户名和密码。
2) 实现步骤
(1) 创建一个新的工程，工程名为ZSSharedPreferences。
(2) 切换工程的Project项目结构。选择该模式下方的App，依次展开，便看到工程的布局界面和工程的类文件，其中，activity_main.xml是布局界面，MainActivity.java为类文件。
(3) 在工程中添加一个新的页面。右击com.example. zssharedpreferences包→New→Activity→Empty Activity，会弹出一个创建活动的对话框，将活动命名为SecondActivity，默认勾选Generate Layout File关联布局界面，布局界面名称为activity_second，但不要勾选Launcher Activity。单击Finish按钮，便完成了第二个页面的添加。
(4) 准备一张图片，图片名为bgtwo.jpg，将其粘贴到app目录结构中res下方的drawable文件夹下，作为登录页面的背景图片。
(5) 修改布局界面。在app目录下的结构中，双击layout文件夹下的activity_main.xml文件，便可打开布局编辑器，切换到Text选项卡，输入代码如下。



<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical"

android:background="@drawable/bgtwo"

tools:context=".MainActivity">

<ImageView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:src="@mipmap/ic_launcher_round"

android:layout_marginTop="150dp"

android:layout_marginBottom="50dp"

android:layout_gravity="center"/>

<EditText

android:id="@+id/editText_inputname"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:hint="请输入用户名"

android:textColor="#000000"

android:textSize="25sp"

android:textStyle="bold"/>

<EditText

android:id="@+id/editText_inputpwd"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:hint="请输入密码"

android:inputType="textPassword"

android:textColor="#000000"

android:textSize="25sp"

android:textStyle="bold"/>

<CheckBox

android:id="@+id/checkBox_reme"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="记住密码"

android:layout_gravity="right"

android:layout_marginRight="10dp"

android:textColor="#000000"

android:textSize="20sp"




android:textStyle="bold"

android:layout_marginTop="10dp"

android:layout_marginBottom="10dp"/>

<Button

android:id="@+id/button_login"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:text="登录"

android:textColor="#000000"

android:textSize="25sp"

android:textStyle="bold"/>

</LinearLayout>


上述代码中，根节点为线性布局，方向为vertical，其内部放置了一个图片控件、输入用户名的EditText控件和输入密码的EditText控件，以及复选框checkBox控件，方便用户选择是否记住密码。最下方是Button控件，用来实现数据存储和跳转功能。
(6) 实现第一个Activity页面的功能。打开MainActivity.java类文件，修改MainActivity的代码如下。



public class MainActivity extends AppCompatActivity {

//第一步：定义对象

EditText edit_name,edit_pwd;

CheckBox check_reme;

Button btn_login;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

//第二步：绑定控件

edit_name=findViewById(R.id.editText_inputname);

edit_pwd=findViewById(R.id.editText_inputpwd);

check_reme=findViewById(R.id.checkBox_reme);

btn_login=findViewById(R.id.button_login);

//第三步：按钮单击事件

btn_login.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//单击按钮将输入的用户名、密码、复选框的状态保存起来

SharedPreferences.Editor editor=getSharedPreferences("myfile",0).edit();

editor.putString("name", edit_name.getText().toString());

editor.putString("pwd",edit_pwd.getText().toString());

editor.putBoolean("st",check_reme.isChecked());

editor.commit();

Intent intent=new Intent(MainActivity.this, SecondActivity.class);

startActivity(intent);

finish();

}

});




//第四步：如果选中了“记住密码”复选框，下一次启动，能够获取用户名和密码并显示出来

String myname=getSharedPreferences("myfile",0).getString("name","");

String mypwd=getSharedPreferences("myfile",0).getString("pwd","");

Boolean myst=getSharedPreferences("myfile",0).getBoolean("st",false);

if(myst==true){

edit_name.setText(myname);

edit_pwd.setText(mypwd);

check_reme.setChecked(true);

}else{

edit_name.setText("");

edit_pwd.setText("");

check_reme.setChecked(false);

}

}

}


上述代码中，在按钮单击事件内部，首先使用SharedPreferences将输入的用户名、密码、复选框的状态存储起来，然后实现页面的跳转，即从当前页面跳转到第二个页面。下次启动时，从SharedPreferences中获取用户名、密码和复选框的状态等数据信息，根据获取的复选框的状态进行判断，如果为真，说明用户选中了“记住密码”，此时将获取的用户名和密码显示到EditText控件上，并将复选框设置为选中。如果为假，说明用户没有选中“记住密码”，EditText控件内容设置为空，并将复选框设置为未选中。
(7) 运行程序，效果如图5.1(a)所示，在界面中输入用户名和密码，选中“记住密码”复选框，单击“登录”按钮，将用户名和密码保存并跳转到第二个页面，再次运行程序，效果如图5.1(b)所示。


图5.1程序运行效果


(8) 查看SharedPreferences中保存的数据。在百度中下载RE文件管理器，把下载好的RE文件管理器软件拖放到模拟器中，模拟器便会开始安装RE文件管理器，大约5s即可安装成功。在模拟器中打开RE文件管理器，挂载为可读写模式，根据文件的存储路径依次操作： data/data/<package name>/shared_prefs/文件名，单击data文件夹，在打开的模拟器页面中再次单击data文件夹，在列表中找到工程的包名com.example.zssharedpreferences，在打开的页面中双击Shared_prefs将其打开，看到了保存的文件名myfile.xml，双击查看保存的用户名和密码信息。


图5.2在模拟器中查看SharedPreferences中保存信息


5.2Android的文件存储
文件存储是Android中最基本的一种数据存储方式，它不会对存储的内容进行任何的格式化处理，它与Java中的文件存储类似，都是通过I/O流的形式把数据原封不动地存储到文档中。不同的是，Android中的文件存储分为内部存储和外部存储，本节分别针对这两种存储方式进行详细的讲解。



微课视频


5.2.1内部存储
内部存储不是内存，它是手机中的一块存储区域，是系统本身和系统应用程序主要的数据存储位置。内部存储是指将应用程序中的数据以文件方式存储到设备的内部存储空间中，与SharedPrefences存储位置类似，文件存储的位置也位于data/data/<package name>/files/目录下。内部存储方式所存储的文件被其所创建的应用程序私有，如果其他应用程序要操作本应用程序中的文件，需要设置权限。当创建的应用程序被卸载时，其内部存储文件也随之删除。
1. 文件内部存储常用方法
Android提供了openFileInput()和openFileOutput()两种方法，向应用程序“读取”和“写入”数据流。按照流向分可以分为输入流和输出流，输入流只能从中读取数据，不能写入数据； 输出流只能向其中写入数据，不能读取数据。写入和读取数据时，按照操作的数据单元分为字节流和字符流，字节流操作的数据单元是8位的字节，字符流操作的数据单元是16位的字节。
系统提供了文件内部存储的方法，如表5.3所示。


表5.3文件内部存储方法



方法功能描述实例


将数据存储到文件中的方法
openFileOutput(String name,int model)得到一个文件输出流对象FileOutputStream类向文件中写入数据FileOutputStream fout = openFileOutput("zs.txt",0)
write(int b) throws IOException一次写一个字节，b表示要写入的字节fout.write(edit_input.getText().toString().getBytes())
write(byte［］ b) throws IOException:一次写一个字节数组
write(byte［］ b, int off,int len) throws IOException:一次写一部分字节数组
close()throws IOException： 关闭此文件输出流并释放与此流有关的所有系统资源fout.close()


从文件中读取数据的方法
openFileInput (String name)得到一个文件输入流对象FileInputStream类
从某个文件中读取字节FileInputStream fin = openFileInput("zs.txt");
public int read() throws IOException从此输入流中读取一个数据字节
public int read(byte［］ b) throws IOException从此输入流中将最多b.length个字节的数据读入一个字节数组中byte［］ arr=new byte［fin.available()］;

fin.read(arr);
public int read(byte［］ b, int off, int len) throws IOException从此输入流中将最多len个字节的数据读入一个字节数组中
public voidclose() throws IOException关闭此文件输入流并释放与此流有关的所有系统资源
fout.close();


删除文件的方法

deleteFile(filename)可以根据文件名，删除文件deleteFile("zs.txt");

上述方法中，openFileOutput()得到一个文件输出流对象FileOutputStream，用于打开应用程序中对应的输出流，将数据存储到指定的文件中。其中，参数name表示文件名； mode表示文件的操作模式，有两种模式可选： MODE_PRIVATE和MODE_APPEND，其中，MODE_PRIVATE是默认的操作模式，表示当指定同名文件的时候，所写入的内容会覆盖原文件中的内容，而MODE_APPEND是追加模式，表示如果该文件已存在，就往文件里面追加内容，不存在就创建新的文件。openFileInput()得到一个文件输入流对象FileInputStream，用于打开应用程序中对应的输入流，读取文件中的内容并显示出来。
Android中文件读写的原理： 首先，所有文件的存储都是字节的存储。其次，在磁盘上保留的并不是文件的字符，而是先把字符编码转换成字节，再存储这些字节到磁盘。最后，在读取文件特别是文本文件时，也是一个字节一个字节地读取以形成字节序列。因此，在存储数据时，需要将字符串类型的数据转换成二进制字节流进行保存。在读取数据时，则需将二进制字节流转换为字符串再显示出来。
2. 文件内部存储案例
1) 案例分析
(1) 界面分析。布局界面中有三个控件： TextView控件用来显示评论人，EditText控件用来输入评论内容，Button控件用来提交评论，提交后评论内容以文件方式保存到内存中。
(2) 设计思路。布局界面中的控件通过添加属性的方式达到用户需求，在按钮单击事件中，调用文件内部存储的方法，将文件保存到内存中，下次运行程序时，读取内存中的文件内容并显示出来，用户可输入新的评论内容并提交，达到用户的需求。
2) 实现步骤
(1) 创建一个新的工程，工程名为ZSFileSave。
(2) 切换工程的Project项目结构。选择该模式下方的app，依次展开，便可看到工程的布局界面和工程的类文件，其中，activity_main.xml是布局界面，MainActivity.java为类文件。
(3) 准备一张图片，图片名为filesavebg.jpg，将其粘贴到app目录结构中res下方的drawable文件夹下，图片作为评论页面的背景图片。
(4) 修改布局界面。在app目录下的结构中，双击layout文件夹下的activity_main.xml文件，便可打开布局编辑器，切换到Text选项卡，输入代码如下。



<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical"

android:background="@drawable/filesavebg"

tools:context=".MainActivity">

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="贝壳评论："

android:textSize="40sp"

android:layout_marginBottom="70dp"

android:layout_marginTop="20dp"/>

<EditText

android:id="@+id/editText_input1"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:layout_margin="5dp"

android:layout_weight="1"

android:background="#A4E49C"

android:gravity="top"

android:hint="请在此留下你的内容"

android:textSize="20sp"

android:textColor="#000000"/>




<Button

android:id="@+id/button_sava1"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:text="提交评论"

android:textSize="30sp"

android:textStyle="bold"

android:background="#009688"

android:textColor="#ffffff"/>

</LinearLayout>


上述代码中，根节点为线性布局，方向为vertical，其内部放置了一个TextView控件用来显示发表评论的用户名，使用EditText控件输入评论内容，最下方是Button控件，用来实现文件存储功能。
(5) 实现提交评论内容的功能。打开MainActivity.java类文件，修改MainActivity的代码如下。



public class MainActivity extends AppCompatActivity {

//第一步：定义对象

private EditText edit_input;

private Button btn_save;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

//绑定控件

initView();

//按钮单击事件，把输入的内容保存到文件里面

onbuttonClick();

//下次打开页面时，读取文件内容，显示出来

readFile();

//完善工程，自动显示当前时间

displaytime();

}

//第二步：绑定控件

private void initView() {

edit_input=findViewById(R.id.editText_input1);

btn_save=findViewById(R.id.button_sava1);

}

//第三步：按钮单击事件

private void onbuttonClick() {

btn_save.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//把输入的内容保存到文件里面

try {

//Context类中提供了一个方法openFileOutput可以实现向文件中写入数据

//参数：(“文件名” , 文件的操作模式：覆盖/追加)，路径：data/data/包名/files/




FileOutputStream fout=openFileOutput("zs.txt",0);

fout.write(edit_input.getText().toString().getBytes());   
//数据写入文件中

fout.close();  //关闭文件输出流

 Toast.makeText(MainActivity.this,"提交成功",Toast.LENGTH_SHORT).show();  
//弹出提示，提交成功

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

});

}

//第四步：下次打开页面时，读取文件内容，显示出来

private void readFile() {

try {

//调用Context类的openFileInput方法得到一个文件输入流对象

FileInputStream fin =openFileInput("zs.txt");

byte［］   arr=new byte［fin.available()］;   
//创建一个数组缓冲区，用来存放读取的很多字节数据

fin.read(arr); //数据的读取

fin.close();   //关闭输入流

edit_input.setText(new String(arr)); //数据显示出来，byte类型的数据转为字符串

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

//第五步：完善工程：自动显示当前时间

private void displaytime() {

Time time=new Time();  //创建一个时间类，注意导入包import android.text.format.Time

time.setToNow();   //获取系统当前时间

edit_input.append("＼n＼n"+time.year+"年"+(time.month+1)+"月"+time.monthDay+"日"+"＼n");//把获取的年月日显示出来

edit_input.setSelection(edit_input.getText().length());//将光标移动至文字末尾

}

}


上述代码中，考虑到程序越来越复杂，onCreate()方法中的代码量会越来越多，为了避免代码混乱，根据程序实现的功能自定义几个方法，这种方式不仅可以让onCreate()内部的代码结构清晰，而且独立的方法有利于程序的复用。方法命名规范一般由两个或多个单词组成，从第二个单词开始首字母大写。
从功能实现角度，在按钮单击事件中，通过openFileOutput文件输出流来保存数据到zs.txt文件中，由于从EditText控件获取用户输入的内容为字符串类型，而所有文件的存储都是采用字节存储的，因此采用getBytes()方法将字符串转换为二进制字节流，再调用write()方法将一个一个字节写入文件进行存储。下次运行程序，用户希望原来存储的数据可以直接显示，此时需要调用openFileInput文件输入流从zs.txt文件中读取内容。首先建立数据存储空间即字节类型的数组arr，然后调用read()方法开始读取数据，并将读取的数据存放到数组arr中，最后将数组中的字节流转换为字符串并显示在EditText控件上。为了提升用户体验，在重新运行App时，自动显示系统时间。
(6) 运行程序，效果如图5.3所示。

(7) 查看保存到内存中的评论内容。在模拟器中打开RE文件管理器，挂载为可读写模式，根据文件的存储路径依次操作： data/data/<package name>/files/文件名，单击data，在打开的模拟器页面中再次单击data，在列表中找到工程的包名com.example. zsfilesave，在打开的页面中显示了刚刚保存的文件zs.txt，如图5.4所示。双击zs.txt将其打开，看到了保存的评论内容，如图5.5所示。


图5.3文件内部存储运行效果图




图5.4查看内部存储文件的保存位置





图5.5查看文件内部存储中保存的信息






微课视频


5.2.2外部存储
手机的内部存储通常不会很大，一旦手机的内部存储容量被用完，可能会出现手机无法使用的情形。对于开发者来说，不宜存储视频等大文件，而适合存储一些小文件。例如，常用的SharedPreferences和SQLite数据库都是存储在内部存储中的，不会占用太大的空间。
1. 外部存储简介
外部存储是指将文件存储到一些外围设备上，如SD卡或者设备内嵌的存储卡，属于永久性的存储方式。外部存储的文件可以被其他应用程序所共享，当将外围存储设备连接到计算机时，这些文件可以被浏览、修改和删除，因此这种方式不安全。
由于外围存储设备可能被移除、丢失或者处于其他状态，因此在使用外围设备之前，建议用户使用Environment.getExternalStorageState()方法来确认外围设备是否可用，当外围设备可用并且具有读写权限时，就可以通过FileInputStream、FileOutputStream或者FileReader、FileWrite对象来读写外围设备中的文件。
2. 外部存储调用的方法
访问外部存储的方法如表5.4所示。


表5.4获取外部存储的方法



获取路径的方法功能描述实例和存储路径
getExternalStorage

Directory()主要的外部存储目录/
mnt/sdcar或者/storage/
emulated/0或者/storage/
sdcard0 String path=Environment.
getExternalStorageDirectory()+ "/"+"zs.txt";

/storage/emulated/0/zs.txt(存储路径)

context.getExternal

CacheDir()应用在外部存储上的缓存目录Stringpath = MainActivity.this.
getExternalCacheDir()+ "/"+"zs.txt";
/storage/emulated/0/Android/data/com.example.filesavetest/cache/zs.txt(存储路径)
context.getExternalFilesDir
(Environment.

DIRECTORY_
MOVIES)应用在外部存储上的目录，其中，movies可更换为任意目录
Stringpath = MainActivity.this.getExternalFilesDir(Environment.
DIRECTORY_MOVIES)+ "/"+"zs.txt";

/storage/emulated/0/Android/data/com.example.filesavetest/files/Movies/ zs.txt (存储路径,文件夹可改为MUSIC、DCIM、PICTURES等)
context.getFilesDir()获取当前程序路径应用在内存上的目录Stringpath = MainActivity.this.getFilesDir()+ "/"+"zs.txt";

/data/data/com.example.filesavetest/files/zs.txt(存储路径)
context.getCacheDir()应用在内存上的缓存目录Stringpath = MainActivity.this.
getExternalCacheDir()+ "/"+
"zs.txt";

/storage/emulated/0/Android/data/com.example.filesavetest/cache/zs.txt(存储路径)

在表5.4中，前三行列举了获取外部存储路径调用的方法，后两行列举了获取当前程序路径应用在内存上目录调用的方法。在Android开发中，用户可根据程序需求自行将文件存放到需要的位置。
3. 文件外部存储案例
1) 案例分析
(1) 界面分析。布局界面中有四个控件，TextView控件用来显示标题，EditText控件用来输入内容，两个Button控件用来保存内容和删除内容，保存后内容以文件方式保存到外存SD卡中。
(2) 设计思路。布局界面中的控件通过添加属性的方式达到用户需求，在“保存”按钮单击事件内部，调用文件外部存储的方法，将文件保存到SD卡中，下次运行程序时，读取SD卡中的文件内容并显示出来。单击“删除”按钮，删除文件内容，达到用户的需求。
2) 实现步骤
(1) 创建一个新的工程，工程名为ZSFileSaveTest。
(2) 切换工程的Project项目结构。选择该模式下方的app，依次展开，便看到工程的布局界面和工程的类文件，其中，activity_main.xml是布局界面，MainActivity.java为类文件。

(3) 准备一张图片，图片名为filesavebgt.jpg，将其粘贴到app目录结构中res下方的drawable文件夹下，图片作为页面的背景图片。
(4) 修改布局界面。在app目录下的结构中，双击layout文件夹下的activity_main.xml文件，便可打开布局编辑器，切换到Text选项卡，输入代码如下。



<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical"

android:background="@drawable/filesavebgt"

tools:context=".MainActivity">

<TextView

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:text="随手记事"

android:textSize="30sp"

android:textColor="#000000"

android:textStyle="bold"

android:gravity="center"

android:layout_marginBottom="10dp"

android:layout_marginTop="80dp"/>

<View

android:layout_width="match_parent"

android:layout_height="5dp"

android:background="#000000"/>

<EditText


android:id="@+id/editText_input1"




android:layout_width="match_parent"

android:layout_height="wrap_content"

android:layout_margin="5dp"

android:layout_weight="1"

android:background="#DF9CE4"

android:gravity="top"

android:hint="请在此留下你的内容"

android:textSize="18sp"

android:textColor="#000000"/>

<View

android:layout_width="match_parent"

android:layout_height="8dp"

android:background="#000000"/>

<LinearLayout

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:orientation="horizontal"

android:layout_marginTop="3dp">

<Button

android:id="@+id/button_sava1"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="保存"

android:textSize="30sp"

android:textStyle="bold"

android:background="#FF5722"

android:textColor="#ffffff"

android:layout_weight="1"/>

<Button

android:id="@+id/button_delete"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="删除"

android:textSize="30sp"

android:textStyle="bold"

android:background="#E91E63"

android:textColor="#ffffff"

android:layout_weight="1"

android:layout_marginBottom="2dp"/>

</LinearLayout>

 </LinearLayout>


(5) 实现外部文件存储与读取功能。重点关注向外围设备(SD卡)中存储数据和从外围设备(SD卡)中读取数据的示例代码，具体如下。



public class MainActivity extends AppCompatActivity {

private static final String TAG = "MainActivity";

//第一步：定义对象


private EditText edit_input1;

private Button btn_save1;




private String path;

private File file;

private String filename="note.txt";

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

//绑定控件

initView();

//按钮单击事件，把输入的内容保存到文件里面

onbuttonClick();

//下次打开页面时，读取文件内容，显示出来

readFile();

//完善工程，自动显示当前时间

displaytime();

}

//第二步：绑定控件

private void initView() {

edit_input1=findViewById(R.id.editText_input1);

btn_save1=findViewById(R.id.button_sava1);

}

//第三步：按钮单击事件

private void onbuttonClick() {

btn_save1.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//把输入的内容保存到文件里面

try {

//利用外部getExternalStorageDirectory获取根目录，直接在后面加上想创建的文件

path = Environment.getExternalStorageDirectory()+ "/"+filename; //路径是：/storage/emulated/0/ note.txt

file = new File(path);   //创建文件

if(!file.exists()){  //文件若不存在则调用file.createNewFile()

file.createNewFile();

}

FileOutputStream fout=openFileOutput(filename,0); //向文件中写内容，自然要创建文件
//输出流的操作

fout.write(edit_input1.getText().toString().getBytes());  //数据写入文件中，调用输出
//流的write方法

fout.close(); //关闭文件输出流

Toast.makeText(MainActivity.this,"提交成功",Toast.LENGTH_SHORT).show(); //弹出提示，
//提交成功

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}


}

});




btn_delete.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

deleteFile(filename); //删除文件

Toast.makeText(MainActivity.this,"删除成功",Toast.LENGTH_SHORT).show();  //弹出提示，
//删除成功

}

});

}

//第四步：下次打开页面时，读取文件内容，显示出来

private void readFile() {

//检查SD卡的状态，Environment.MEDIA_MOUNTED表示SD卡在手机上正常使用状态

if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){

//SD卡可用，可以开始读取数据

try {

 FileInputStream fin =openFileInput(filename);  //调用Context类openFileInput方法得到一个
//文件输入流对象

 byte［］   arr=new byte［fin.available()］;   //创建一个数组缓冲区，用来存放读取的数据

fin.read(arr);   //数据的读取

fin.close();  //关闭输入流

edit_input1.setText(new String(arr));  //数据显示出来，byte类型的数据转
//为字符串

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}else{

//SD卡不可用

Toast.makeText(MainActivity.this,"SD卡不可用",Toast.LENGTH_SHORT).show();

}

}

//第五步：完善工程：自动显示当前时间

private void displaytime() {

Time time=new Time();   //创建一个时间类，导入包import android.text.format.Time;

time.setToNow();  //获取系统当前时间

edit_input1.append("＼n＼n"+time.year+"年"+(time.month+1)+"月"+time.monthDay+"日"+"＼n");//把获取的年月日显示出来

edit_input1.setSelection(edit_input.getText().length()); //将光标移动至文字末尾

}

}


上述代码中，向外围设备(SD卡)中存储数据时，使用到了Environment.getExternalStorageDirectory()方法，该方法用于获取SD卡的路径。针对不同手机厂商SD卡根目录也不完全一致，用这种方法可以避免把路径写死而找不到SD卡。在该路径下创建文件，运行时文件若不存在则调用file.createNewFile()方法创建文件，之后创建文件输出流对象，调用write()方法向文件中写内容。
从外围设备(SD卡)中读取数据时，需要判断外围设备是否可用，Environment.getExternalStorageState()方法用来确认外围设备是否可用，Environment.MEDIA_MOUNTED表示SD卡处于正常使用状态，当外围设备可用并且具有读写权限时，通过FileInputStream对象读取指定目录下的文件。
(6) 声明权限。Android系统为了保证应用程序的安全性做了相应规定，如果程序需要访问系统的一些关键信息，如读写SD卡、访问Internet、打开相机、访问相册、访问通讯录等，必须在工程的配置文件AndroidManifest.xml中声明权限才可使用，否则程序运行时会直接崩溃。这里操作SD卡的信息就是系统中比较关键的信息，因此需要在清单文件的<manifest>节点下配置权限信息，切换工程的Project项目结构。选择该模式下方的app→src→main→AndroidManifest.xml依次展开，双击打开AndroidManifest.xml配置文件，具体代码如下。




<manifest xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:tools="http://schemas.android.com/tools"

package="com.example.filesavetest">

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

<application

…


上述代码指定了当前App程序具有读写外部SD卡的权限，因此应用程序便可以操作SD卡中的数据。
(7) 运行程序，效果如图5.6所示。
(8) 查看保存到外存中的随手记事内容。在模拟器找到文件管理器，双击打开文件管理器，根据文件的存储路径依次操作： /storage/emulated/0/note.txt文件名，单击storage文件夹，打开的模拟器页面中单击emulated文件夹，单击0文件夹，在打开的页面中显示了刚刚保存的文件note.txt，如图5.7所示。双击note.txt将其打开，便可查看随手记事的文件内容。


图5.6文件外部存储运行效果图



图5.7查看外部存储文件的保存位置





微课视频


5.3调用摄像头和相册
在使用QQ或者微信的时候经常要和别人分享图片，这些图片可以是用手机摄像头拍的，也可以是从相册中选取的。类似这样的功能太常见了，那么本节就学习一下调用摄像头和相册方面的知识。



微课视频


5.3.1调用摄像头拍照
现在很多应用都会要求用户上传一张图片来作为头像，这时打开摄像头拍张照片是最简单快捷的，下面通过一个例子来学习一下，如何才能在应用程序中调用手机的摄像头进行拍照。
1. 案例分析
(1) 界面分析。布局界面中有两个控件，其中，Button控件用来打开相机拍照，ImageView控件用来把拍摄的照片显示出来。
(2) 设计思路。布局界面中的控件通过添加属性的方式达到用户需求，单击拍照按钮时利用隐式跳转打开系统相机，并将拍摄的照片存放到指定的路径下，拍照结束后通过系统回调将拍摄的照片显示出来，达到用户的需求。
2. 实现步骤
(1) 创建一个新的工程，工程名为ZSPhoto。
(2) 切换工程的Project项目结构，选择该模式下方的app，依次展开，便看到工程的布局界面和工程的类文件，其中，activity_main.xml是布局界面，MainActivity.java为类文件。
(3) 准备一张图片，图片名为zsphotobg.jpg，将其粘贴到app目录结构中res下方的drawable文件夹下，作为页面的背景图片。
(4) 设计布局界面。双击layout文件夹下的activity_main.xml文件，便可打开布局编辑器，修改布局类型为LinearLayout，添加方向属性为vertical。依次添加两个控件，代码如下。



<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical"

android:background="@drawable/zsphotobg"

tools:context=".MainActivity">

<ImageView

android:id="@+id/imageView_cam"

android:layout_width="match_parent"

android:layout_height="200dp"




android:src="@mipmap/ic_launcher_round"

android:layout_gravity="center"/>

<Button

android:id="@+id/button_cam"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:textColor="#000000"

android:text="拍照"

android:textSize="30sp"/>

</LinearLayout


上述代码中，Button控件用来打开系统相机，ImageView控件用来显示拍摄的图片。
(5) 按钮单击事件处理。打开MainActivity.java类文件，修改MainActivity的代码，具体如下。



public class MainActivity extends AppCompatActivity {

private static final String TAG = "MainActivity";

//定义对象

private  ImageView img_camer;

private  Button btn_camer;

//定义一个路径： ①拍照的临时路径; ②显示照片的最终路径

String tmp_path,disp_path;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

//绑定控件

initView();

//“拍照”按钮单击事件

btnCamOnclick();

//拍完照之后，接收照片并显示,系统回调 

}

//第一步：绑定控件

private void initView() {

img_camer=findViewById(R.id.imageView_cam);

btn_camer=findViewById(R.id.button_cam);

}

//第二步：拍照按钮单击事件

<private void btnCamOnclick() {

btn_camer.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

Log.d(TAG, "onClick:1 "+"单击了按钮");>

//拍照代码

//前期准备：路径

<tmp_path=Environment.getExternalStorageDirectory()+"/img_"+randFileName()+".jpg";

File imgfile=new File(tmp_path);>//创建保存照片的文件，照片都保存到本路径下




try {

if(imgfile.exists()){

imgfile.delete();

}

imgfile.createNewFile();

} catch (IOException e) {

e.printStackTrace();

}

Intent intent=new Intent("android.media.action.IMAGE_CAPTURE"); 
 //1.创建一个打开相机的Intent

intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(imgfile));    
//2.告诉相机图片的保存位置

startActivityForResult(intent,11);     //3.打开相机

}

});

}

}

//第三步：拍完照之后，接收照片并显示,系统回调

@Override

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

switch (requestCode){

case 11:

if (resultCode==RESULT_OK){

//根据照片的真实路径来显示照片

disp_path=tmp_path;   //确定图片的路径

Glide.with(MainActivity.this).load(disp_path).into(img_camer); 
//显示照片

}

break;

default:

break;

}

}

//时间戳，为了保证每次拍的照片都能以不同的文件名保存到SD卡上

private String randFileName(){

Time t=new Time();

t.setToNow();   //取得系统时间

String  strtime=t.year+""+(t.month+1)+""+t.monthDay+""+t.hour+""+t.minute+""+t.second+"";

return strtime;

}

}


上述代码中，在onCreate()方法内部自定义两个方法： initView()方法内部放绑定控件的代码，btnCamOnclick()方法内部放按钮单击事件的代码。这种方式不仅可以让onCreate()内部的代码结构清晰，而且独立的方法有利于程序的复用。
在按钮单击事件内部书写拍照代码，拍照之前先准备好照片的存放路径，调用Environment.getExternalStorageDirectory()方法将拍摄的照片存放到外存的SD卡上。为了保证拍摄的照片能够全部保存到SD卡上，采用时间戳为图片文件名的一部分，这样可以确保文件名的唯一。路径确定好之后，调用createNewFile()方法在该路径下创建保存照片的文件，一切前期工作准备就绪，就可以通过隐式跳转的方式打开系统相机，同时告诉相机拍完之后图片的保存位置，通过startActivityForResult(intent,11)启动活动，方法中传递了期望在活动销毁时能够返回一个结果给上一个活动的请求码11，用于在之后的回调中判断数据的来源。因此，当相机拍照结束以后，会回调上一个活动的onActivityResult()方法，因此需要在MainActivity类文件中重写这个方法来得到返回的数据。
onActivityResult()方法中有三个参数： 第一个参数requestCode是在启动相机活动时传入的请求码，第二个参数resultCode是返回数据时传入的处理结果，第三个参数data是携带者返回数据的Intent。首先通过检查requestCode判断数据的来源，再通过resultCode的值判断处理结果是否成功，最后通过Glide图片加载库根据图片的路径将图片显示到ImageView控件中。
(6) Glide图片加载库。Glide是一个被Google所推荐的图片加载库，作者是bumptech。这个库被广泛运用在Google的开源项目中。Glide是滑行的意思，可以看出这个库的主旨就在于让图片加载变得流畅。使用Glide时需要在Android Studio上添加依赖，切换工程的Project项目结构。选择该模式下方的app→src→ build.gradle依次展开，双击打开build.gradle文件，添加Glide依赖，只需添加一行代码即可，代码如下。



apply plugin: 'com.android.application'

…

dependencies {

implementation fileTree(dir: 'libs', include: ［'*.jar'］)

…

androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'

implementation 'com.github.bumptech.glide:glide:4.9.0'

}


(7) 声明权限。因为要访问系统相机，因此需要在清单文件的<manifest>节点下配置权限信息，切换工程的Project项目结构。选择该模式下方的app→src→main→AndroidManifest.xml依次展开，双击打开AndroidManifest.xml配置文件，具体代码如下。



<manifest xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:tools="http://schemas.android.com/tools"

package="com.example.filesavetest">

<uses-permission android:name="android.permission.CAMERA"/>

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>



<application

…


上述代码指定了当前SD卡具有可写可读的权限，同时指定了本程序具有访问系统相机的权限，因此应用程序不仅可以打开系统相机拍照，而且还可以操作SD卡中的图片文件。
(8) 运行程序，效果如图5.8所示。


图5.8打开摄像头拍照和拍照的最终效果





微课视频


5.3.2从相册中选择照片
虽然调用摄像头拍照既方便又快捷，但并不是每次都需要去当场拍照，因为每个人的手机相册里应该会有很多图片，直接从相册里选择一张现有的照片会比打开相机拍摄一张照片更加常用。一个优秀的应用程序应该将这两种选择方式都提供给用户，由用户决定使用哪一种。下面就来看一下如何才能实现从相册中选择照片。
1. 案例分析
(1) 界面分析。布局界面中有两个控件，其中，Button控件用来打开相册，ImageView控件用来把选择的照片显示出来。
(2) 设计思路。布局界面中的控件通过添加属性的方式达到用户需求，单击Button打开相册时利用隐式跳转打开手机相册，照片选择结束后通过系统回调将选择照片显示出来，达到用户的需求。
2. 实现步骤
(1) 无须创建新工程，在拍照案例工程ZSPhoto中继续完善程序即可。
(2) 完善设计布局界面。双击layout文件夹下的activity_main.xml文件，便可打开布局编辑器，在布局界面上拍照案例的两个控件保持不动，继续添加两个控件，代码如下。



<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical"

android:background="@drawable/zsphotobg"

tools:context=".MainActivity">



…



<Button

android:id="@+id/button_photo"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:textColor="#000000"

android:text="从相册选择"

android:textSize="30sp"/>

<ImageView

android:id="@+id/imageView_photo"

android:layout_width="match_parent"

android:layout_height="200dp"

android:src="@drawable/ic_launcher_background"

android:layout_gravity="center"/>

</LinearLayout>


上述代码中，Button控件用来打开系统相册，ImageView控件用来显示选择的图片。
(3) “选择相册”按钮功能。打开MainActivity.java类文件，完善从相册中选择图片的功能，代码如下。



public class MainActivity extends AppCompatActivity {

private static final String TAG = "MainActivity";

//定义对象

private ImageView img_camer,img_photo;

private Button btn_camer,btn_photo;

//定义一个路径： ①拍照的临时路径; ②显示照片的最终路径

String tmp_path,disp_path;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

//手动开启程序权限之后，拍照仍闪退，解决拍照闪退问题

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {

StrictMode.VmPolicy.Builder builder = new StrictMode.VmPolicy.Builder();

StrictMode.setVmPolicy(builder.build());

}





//绑定控件

initView();

//拍照按钮单击事件

btnCamOnclick();

//拍完照之后，接收照片并显示,系统回调

//“打开相册”按钮单击事件

btnPhoOnclick();

}

//第一步：绑定控件

private void initView() {

img_camer=findViewById(R.id.imageView_cam);

btn_camer=findViewById(R.id.button_cam);

img_photo=findViewById(R.id.imageView_photo);

btn_photo=findViewById(R.id.button_photo);

}

//第二步：“拍照”按钮单击事件

private void btnCamOnclick() {

btn_camer.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//打开相机拍照按钮，拍照案例已有，这里代码省略

…

}

});

}

//第四步：“打开相册”按钮单击事件

private void btnPhoOnclick() {

btn_photo.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//打开相册

Intent intent=new Intent("android.intent.action.GET_CONTENT");   
//创建打开相册的Intent

intent.setType("image/*");         //打开页面的类型

startActivityForResult(intent,22);   //打开相册

}

});

}

//第三步：拍完照之后，接收照片并显示，系统回调

@Override

protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {

switch (requestCode){

case 11:

if (resultCode==RESULT_OK){

//根据照片的真实路径来显示照片

disp_path=tmp_path;   //确定图片的路径

Glide.with(MainActivity.this).load(disp_path).into(img_camer); 
//显示照片






}

break;

case 22:

if(resultCode==RESULT_OK){

//根据选择照片的路径，显示照片

Uri imageuri=data.getData();   //这是一个缩略图

if (imageuri==null){

return;

}

disp_path= UriUtils.uri2File(imageuri).getPath();   
//将缩略图转换为真实的图片路径

Glide.with(MainActivity.this).load(  disp_path ).into(img_photo);

}

break;

default:

break;

}

}

//时间戳，为了保证每次拍的照片都能以不同的文件名保存到SD卡上

private String randFileName(){

Time t=new Time();

t.setToNow();   //取得系统时间

String  strtime=t.year+""+(t.month+1)+""+t.monthDay+""+t.hour+""+t.minute+""+t.second+"";

return strtime;

}

}


上述代码中，利用隐式跳转android.intent.action.GET_CONTENT打开系统页面，调用setType("image/*")方法设定打开页面的类型为图片，系统回调中，通过返回的数据data.getData()得到图片的缩略图路径，之后调用UriUtils.uri2File(imageuri).getPath()方法将缩略图转换为真实的图片路径，最后通过Glide图片加载库根据图片的真实路径将图片显示到ImageView控件中。
(4) 将图片的缩略图路径转换为真实路径的方法。UriUtils是一个依赖，需要在Android Studio上添加依赖，切换工程的Project项目结构，选择该模式下方的app→src→build.gradle依次展开，双击打开build.gradle文件，添加UriUtils依赖，代码如下。



dependencies {

implementation fileTree(dir: 'libs', include: ［'*.jar'］)

…

implementation 'com.github.bumptech.glide:glide:4.9.0'

api 'com.blankj:utilcode:1.23.7'

}


(5) 运行程序，效果如图5.9所示。


图5.9打开手机相册和选择照片的最终效果



5.4Android运行时权限设置
Android的权限机制并不是什么新鲜事物，从系统的第一个版本开始就已经存在了，但其实之前Android的权限机制在保护用户安全和隐私等方面起到的作用非常有限，为了更好地保护用户的安全和隐私，安卓系统的权限管理机制从API 23即Android 6.0之后发生了比较大的改变，在一些比较危险的权限上要求必须申请动态权限。那么本节就来详细学习一下Android 6.0系统中引入的新特性。
5.4.1Android权限机制介绍
1. 动态权限需求原因

Android 6.0之前，权限在应用安装过程中只询问一次，以列表的形式展现给用户，然而大多数用户并不会注意到这些，直接就下一步了，应用安装成功后就会被赋予清单文件中的所有权限，应用就可以在用户不知情的情况下进行非法操作，如偷偷地上传用户数据等。其次，有些常用软件普遍存在着滥用权限的情况，如微信所申请的权限列表： 存储、您的位置、电话、相机、短信、通讯录、身体传感器、麦克风等，其中的短信权限与微信关系不大，但用户若不认可微信所申请的所有权限，那么微信则会安装失败。
Android开发团队也意识到了这个问题，于是在Android 6.0系统中加入了运行时动态权限申请，也就是说，用户不需要在安装软件的时候一次性授权所有申请的权限，而是可以在软件使用的过程中再对某一项权限申请进行授权。例如，一款相机应用在运行时申请了地理位置定位权限，即使用户拒绝了这个权限，仍然可以使用这个应用的其他功能，而不是像之前那样直接无法安装软件。
2. 需要动态申请的权限
并不是所有权限都需要在运行时申请，对于用户来说，不停地授权也很烦琐。Android现在将所有的权限归成了两类： 一类是普通权限，一类是危险权限。普通权限指的是那些不会直接威胁到用户的安全和隐私的权限，对于这部分权限申请系统会自动授权，无须用户手动操作，例如，查看网络连接权限和开机启动权限。危险权限则是表示那些可能会触及用户隐私或者对设备安全性造成影响的权限，如获取设备联系人信息、定位设备的地址位置等，对于这部分权限申请，必须要由用户手动授权才可以，否则程序就无法使用相应的功能。
但是Android中一共有上百种权限，怎么区分哪些是普通权限、哪些是危险权限呢？其实并不难，因为危险权限总共就那么几个，除了危险权限之外，剩余的都是普通权限。Android中所有的危险权限如表5.5所示。


表5.5需要动态申请的权限



权限名功能描述实例

WRITE_EXTERNAL_STORAGE
READ_EXTERNAL_STORAGE外部存储权限<usespermission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> 
CAMERA调用相机权限
RECORD_AUDIO录音权限
<usespermission android:name="android.permission.RECORD_AUDIO"/>
BODY_SENSORS
传感器权限
<usespermission android:name="android.permission.BODY_SENSORS"/>
WRITE_CALENDAR

READ_CALENDAR读写日历权限
<usespermission android:name="android.permission.WRITE_CALENDAR"/>
READ_CONTACTS

WRITE_CONTACTS

GET_ACCOUNTS
通讯录权限
<usespermission android:name="android.permission.READ_CONTACTS" />
SEND_SMS

RECEIVE_SMS

READ_SMS

RECEIVE_WAP_PUSH

RECEIVE_MMS

USE_SIP PROCESS_OUTGOING_CALLS
消息权限
<usespermission android:name="android.permission.SEND_SMS"/>
CALL_PHONE

READ_PHONE_STATE

READ_CALL_LOG

WRITE_CALL_LOG

ADD_VOICEMAIL
手机状态相关
<usespermission android:name="android.permission.CALL_PHONE" />
ACCESS_FINE_LOCATION

ACCESS_COARSE_LOCATION
定位权限
<usespermission android:name="android.permission.ACCESS_FINE_LOCATION"/>

表5.5中的权限共9大类，24个权限，使用时从表中查看即可，如果是属于这张表中的权限，不仅需要在AndroidManifest.xml文件中添加权限声明，而且还要在程序代码中进行权限动态申请，如果所需的权限不在这张表中，那么只需要在AndroidManifest.xml文件中添加权限声明就可以了。
5.4.2在程序运行时申请权限
1. 判断Android系统版本

在官方文档中，可以看到低于API23 是不需要使用动态权限申请的，如果是Android 6.0以上的系统，需要进行判断，代码如下。



if (Build.VERSION.SDK_INT>=23) {        

//此处做动态权限申请    

}

else {      

//低于23 不需要特殊处理   

}

}


2. 运行时申请权限案例
1) 案例分析
(1) 界面分析。布局界面中有两个控件，其中，TextView控件用来显示一段文字，Button控件用来打电话。
(2) 设计思路。布局界面中的控件通过添加属性的方式达到用户需求，单击Button时，弹出“需要使用电话权限，是否允许？”的提示，如果禁止则程序关闭，如果允许则开始拨打电话，达到用户的需求。
2) 实现步骤
(1) 创建一个新的工程，工程名为ZSRuntimePermission。
(2) 切换工程的Project项目结构，选择该模式下方的app，依次展开，便看到工程的布局界面和工程的类文件，其中，activity_main.xml是布局界面，MainActivity.java为类文件。
(3) 准备一张图片，图片名为runtimepbg.jpg，将其粘贴到app目录结构中res下方的drawable文件夹下，作为页面的背景图片。
(4) 修改布局界面。在app目录下的结构中，双击layout文件夹下的activity_main.xml文件，便可打开布局编辑器，切换到Text选项卡，输入如下代码。



<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical"




android:background="@drawable/runtimepbg"

tools:context=".MainActivity">

<TextView

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:text="动态申请权限"

android:textStyle="bold"

android:textSize="30sp"

android:textColor="#0000ff"

android:gravity="center"

android:layout_marginTop="100dp"/>

<Button

android:id="@+id/button_dadianhua"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:text="拨打电话"

android:textStyle="bold"

android:textSize="40sp"

android:textColor="#ff0000"

android:gravity="center"

android:layout_marginTop="50dp"/>

</LinearLayout>


上述代码中，根节点为线性布局，方向为vertical，其内部放置了一个TextView控件用来显示提示文字，下方是Button控件，单击按钮可拨打电话。
(5) 实现打电话功能。打开MainActivity.java类文件，修改MainActivity的代码，如下。



public class MainActivity extends AppCompatActivity {

//定义对象

private Button btn_dadianhua;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

//绑定控件

initView();

//按钮单击事件

btnOnClick();

}

//绑定控件

private void initView() {

btn_dadianhua = findViewById(R.id.button_dadianhua);

}

//按钮单击事件

private void btnOnClick() {

btn_dadianhua.setOnClickListener(new View.OnClickListener() {

@Override




public void onClick(View view) {

//检查权限:判断Android版本是否大于23 

//参数：上下文Context和权限的名称。PERMISSION_GRANTED表示存在权限

if (Build.VERSION.SDK_INT >23) {

if (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.CALL_PHONE)!= PackageManager.PERMISSION_GRANTED) {

//申请权限

ActivityCompat.requestPermissions(MainActivity.this, new String［］{Manifest.permission.CALL_PHONE},11);

}else {

//权限同意，不需要处理，调用打电话的方法

callPhone();

}

} else {

//低于23，不需要特殊处理

callPhone();

}

}

});

}

/** 注册权限申请回调

* @param requestCode 申请码：在申请权限的时候使用的唯一的申请码

* @param permissions 申请的权限：String［］ permission则是权限列表，一般用不到

* @param grantResults 结果：int［］ grantResults 是用户的操作响应，包含该权限则请求成功

*  由于在权限申请的时候，我们就申请了一个权限，所以此处的数组的长度都是1

*/

@Override

public void onRequestPermissionsResult(int requestCode, String［］ permissions, int［］ grantResults)

{

switch (requestCode)  //当权限较多时，建议使用Switch

{

case  11:

if (grantResults［0］ == PackageManager.PERMISSION_GRANTED){

//权限申请成功

callPhone();

}else {

//权限申请失败

Toast.makeText(MainActivity.this, "权限申请失败，用户拒绝权限", Toast.LENGTH_SHORT).show();

}

break;

default:

break;

}

}

/**

* 拨号方法




*/

private void callPhone()

{

Intent intent = new Intent();

intent.setAction(Intent.ACTION_CALL);

intent.setData(Uri.parse("tel:10086"));

startActivity(intent);

}

}


以上代码中，低于API23 是不需要使用动态权限申请的，所以首先检测Android系统版本，如果版本高于23，使用ContextCompat.CheckSlefPermission方法检查一下有没有权限，该方法有两个参数： 上下文Context和权限的名称。返回值PERMISSION_GRANTED表示存在权限，PERMISSION_DENIED 表示不存在权限，使用方法的返回值和PackageManager.PERMISSION_GRANTED做比较，相等就说明用户已经授权，不等就表示用户没有授权。
如果已授权，直接去执行拨打电话的逻辑操作就可以了。这里把拨打电话的逻辑封装到了callPhone()方法当中。如果没有授权，则需要调用ActivityCompat.requestPermissions()方法向用户授权。
requestPermissions方法包含三个参数： 参数1是当前上下文； 参数2是一个权限数组，把权限名放到数组中即可； 参数3是请求码。使用权限数组，说明可以一次申请多个权限。请求码只要是唯一值就可以了，取值要大于0，小于65535，这里传入11。由于这个权限请求是异步操作的，所以用户判断权限后需要回调函数，就用到这个请求码。
调用完requestPermissions()方法之后，系统会弹出一个权限申请的对话框，用户可以选择同意或拒绝权限申请，不论是哪种结果，最终都会回调到onRequestPermissionsResult()方法中。
回调函数的处理。由于程序是异步操作，在用户完成了操作后，需要调用回调函数，而此回调函数则是onRequestPermissionsResult()方法，该方法有3个参数： requestCode是申请权限的时候使用的唯一的申请码； String［］ permission则是权限列表，一般用不到； int［］ grantResults 中封装了授权的结果。由于在权限申请的时候，申请了一个权限，所以此处的数组的长度都是1，这里需要判断一下最后的授权结果，如果用户已同意授权就调用callPhone()方法拨打电话，如果用户拒绝的话程序放弃操作，并且弹出一条失败的提示。
(6) 声明权限。因为打电话会涉及手机的资费问题，因而被列为危险权限，因此必须在AndroidManifes.xml中加入权限声明，否则运行时程序就会崩溃。切换工程的Project项目结构。选择该模式下方的app→src→main→AndroidManifest.xml依次展开，双击打开AndroidManifest.xml配置文件，具体代码如下。



<manifest xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:tools="http://schemas.android.com/tools"

package="com.example. zsruntimepermission">




<uses-permission android:name="android.permission.CALL_PHONE"/>



<application

…


(7) 运行程序，效果如图5.10所示。


图5.10运行时权限申请效果


如果用户在低于6.0系统的设备上安装该程序，用户可以在应用管理界面查看任意一个程序的权限申请情况。在Android 5.0系统模拟器中查看权限方法为： “设置”→“应用管理”→ZSRuntimePermission，这样就可以非常清楚地知晓程序一共申请了哪些权限。同样，采用相同的步骤在Android 6.0系统真机上也可以查看该程序的权限，如图5.11所示。


图5.11Android 5.0系统和Android 6.0系统权限展示





微课视频


5.5实战案例——记忆的仓库： 备忘录
时间如流水，几度夕阳红，回首往事，当迫不及待想记录一些事情的时候，有些人会选择用最原始的笔记本记录，但随着社会的发展，出现了新型的记录方式，经常伴随我们左右的智能手机和笔记本电脑也给用户随手记录提供了便利。本节将利用本章所学习的知识，设计和实现一款私人定制的手机备忘录App，该备忘录功能简洁实用、界面美观、安全性高、易学易用，让我们一起动手开始私人订制的备忘录之旅吧！



微课视频


5.5.1界面分析
本案例中包含三个界面： 登录界面、主界面和信息添加界面，效果如图5.12所示。


图5.12备忘录界面效果图





微课视频


5.5.2实现思路
第一个界面是登录界面，用来保护备忘录信息的安全，采用SharedPreference键值对存储技术来保存用户名和密码； 第二个界面是主界面，以滚动列表方式显示所有的备忘录信息，采用RecyclerView滚动控件和SQLite数据库实现； 第三个界面是信息添加界面，用来添加新的备忘录内容，输入的标题和内容及选择的心情图片都会保存到SQLite数据库中。



微课视频


5.5.3任务实施
【任务51】使用SharedPreferences保存输入的用户名和密码
(1) 创建一个新的工程，工程名为MyMemoTest。
(2) 切换工程的Project项目结构，选择该模式下方的app，依次展开，便看到工程的布局界面和工程的类文件，其中，activity_main.xml是布局界面，MainActivity.java为类文件。
(3) 在工程中添加新的页面。右击com.example.zsintent包→New→Activity→Empty Activity，会弹出一个创建活动的对话框，将活动命名为LoginActivity，默认勾选Generate Layout File关联布局界面，布局界面名称为activity_login但不要勾选Launcher Activity。单击Finish按钮，便可在工程中完成第二个页面的添加。同理，添加第三个页面，类文件为AddInfoActivity，布局界面名称为activity_add_info。
(4) 准备两张图片，图片名为bgone.png和bgthree.jpg，将其粘贴到app目录结构中res下方的drawable文件夹下，作为登录页面和备忘录添加页面的背景图片。
(5) 准备三张小图片，将其粘贴到app目录结构中res下方的drawable文件夹下。其中，buttonbg.png和savebg.png两张小图片作为“添加备忘录”按钮和“保存”按钮的背景图片，sunshine.jpg图片显示到备忘录添加页面的图片控件中。
(6) 设计第一个Activity的布局界面。双击layout文件夹下的activity_login.xml文件，便可打开布局编辑器，修改布局类型为LinearLayout，添加方向属性为vertical。依次添加控件，代码如下。



<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical"

android:background="@drawable/bgone"

tools:context=".LoginActivity">

<TextView

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:text="用户登录"

android:textStyle="bold"

android:textColor="#000000"

android:textSize="40sp"

android:layout_margin="100dp"

android:gravity="center"/>

<LinearLayout

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:orientation="horizontal"

android:layout_margin="10dp">

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="用户名："

android:textColor="#000000"

android:textSize="30sp"/>




<EditText

android:id="@+id/editText_inputname"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:hint="请输入用户名"

android:textColor="#000000"

android:textSize="30sp" />

</LinearLayout>

<LinearLayout

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:orientation="horizontal"

android:layout_margin="10dp">

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="密    码："

android:textColor="#000000"

android:textSize="30sp"/>

<EditText

android:id="@+id/editText_inputpwd"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:hint="请输入密码"

android:textColor="#000000"

android:inputType="textPassword"

android:textSize="30sp"/>

</LinearLayout>

<CheckBox

android:id="@+id/checkBox_reme"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="记住密码"

android:layout_gravity="right"

android:layout_margin="10dp"/>

<LinearLayout

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:orientation="horizontal"

android:layout_margin="10dp">

<Button

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="取消"

android:textColor="#000000"

android:textSize="30sp"

android:layout_weight="1"/>

<Button

android:id="@+id/button_login"




android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="登录"

android:textColor="#000000"

android:textSize="30sp"

android:layout_weight="1"/>

</LinearLayout>

</LinearLayout>


(7) 实现第一个Activity页面的功能。获取EditText控件输入的用户名和密码，采用getSharedPreferences键值对方式存储起来，根据复选框的状态进行判断，如果选中“记住密码”复选框则获取保存的用户名和密码并显示，如果没有选中“记住密码”复选框，则清空EditText控件的内容。打开LoginActivity.java类文件，修改LoginActivity的代码如下。



public class LoginActivity extends AppCompatActivity {

//定义对象

private EditText edit_inputname,edit_inputpwd;

private CheckBox check_reme;

private Button btn_login;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_login);

//1.绑定控件

initView();

//2.单击“登录”按钮，将用户名和密码保存起来

btnloginonClick();

//3.下次启动，直接显示用户名和密码

displayinfo();

}

//1. 绑定控件

private void initView() {

edit_inputname=findViewById(R.id.editText_inputname);

edit_inputpwd=findViewById(R.id.editText_inputpwd);

check_reme=findViewById(R.id.checkBox_reme);

btn_login=findViewById(R.id.button_login);

}

//2.单击“登录”按钮，将用户名和密码保存起来

private void btnloginonClick() {

btn_login.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//保存用户名和密码

SharedPreferences.Editor editor=getSharedPreferences("myinfo",0).edit();

editor.putString("name",edit_inputname.getText().toString());

editor.putString("pwd",edit_inputpwd.getText().toString());

editor.putBoolean("st",check_reme.isChecked());

editor.commit();




//跳转到第二页

Intent intent=new Intent(LoginActivity.this,MainActivity.class);

startActivity(intent);

}

});

}

//3.下次启动，直接显示用户名和密码

private void displayinfo() {

String strname=getSharedPreferences("myinfo",0).getString("name","");

String strpwd=getSharedPreferences("myinfo",0).getString("pwd","");

Boolean status=getSharedPreferences("myinfo",0).getBoolean("st",false);

if(status==true){

edit_inputname.setText(strname);

edit_inputpwd.setText(strpwd);

check_reme.setChecked(true);

}else{

edit_inputname.setText("");

edit_inputpwd.setText("");

check_reme.setChecked(false);

}

}

}


上述代码中，在按钮单击事件的内部，先将用户名和密码保存起来，再跳转到下一个页面。当用户第二次运行程序时会根据复选框是否被选中的状态进行判断，从而确定是否显示用户名和密码。
(8) 修改AndroidManifest.xml配置文件，使程序运行时从第一个界面启动，代码如下。



<activity android:name=".AddInfoActivity"></activity>

<activity android:name=".LoginActivity" >

<intent-filter>

<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>

</activity>

<activity android:name=".MainActivity">

</activity>

…





微课视频


(9) 运行程序，效果如图5.13所示。


图5.13登录界面效果图


【任务52】使用RecyclerView设计主界面
(1) 设计第二个Activity的布局界面。因在第二个布局界面中用到了Android新增的控件RecyclerView，为了让RecyclerView在所有的Android版本上都能使用，Android团队将RecyclerView定义在了Support库当中，如果想使用RecyclerView这个控件，只需在Project项目结构中app→build.gradle文件中添加相应的依赖库才行。打开app/build.gradle文件，在dependencies闭包中添加如下内容。



dependencies {

implementation fileTree(dir: 'libs', include: ［'*.jar'］)

implementation 'com.android.support:appcompat-v7:+'

…

implementation 'com.android.support:recyclerview-v7:+'

}


需要注意的是，recyclerview版本号要与第三行代码support的版本号保持一致。添加完成后，单击本页面右上角的Sync Now来进行同步。
(2) 修改主界面的布局界面。双击layout文件夹下的activity_main.xml文件，便可打开布局编辑器，修改布局类型为LinearLayout，添加方向属性为vertical。依次添加所需控件，代码如下。



<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical"

tools:context=".MainActivity">

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="愿这小小的备忘录，记下我生活中的点点滴滴"

android:textStyle="bold"



android:textColor="#000000"

android:layout_gravity="center"

android:layout_margin="10dp"/>

<Button

android:id="@+id/button_add"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="添加备忘录"

android:textStyle="bold"

android:textColor="#000000"

android:layout_gravity="right"

android:background="@drawable/buttonbg"

android:layout_margin="10dp"/>

<android.support.v7.widget.RecyclerView

android:id="@+id/recy_view"

android:layout_width="match_parent"

android:layout_height="wrap_content"/>

</LinearLayout>


上述代码设计的布局界面非常简单，整体为线性布局，自上而下的垂直方向，TextView控件用来显示一段文字，Button控件用来跳转到下个页面，RecyclerView控件用来显示用户添加的备忘录信息。
(3) 实现第二个Activity页面的功能。打开MainActivity.java类文件，修改MainActivity的代码，如下。



public class MainActivity extends AppCompatActivity {

//定义对象

private Button btn_add;

private RecyclerView recy_view;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

//1.绑定控件

initView();


//2.对按钮添加单击事件

btnonclicknext();

}

//1.绑定控件

private void initView() {

btn_add=findViewById(R.id.button_add);

recy_view=findViewById(R.id.recy_view);

 }

//2.对按钮添加单击事件

private void btnonclicknext() {

btn_add.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {




//单击后跳转到一下页

Intent intent=new Intent(MainActivity.this,AddInfoActivity.class);

startActivity(intent);

finish();

}

});

}

}


上述代码是主界面的一部分代码，由于用户还未添加备忘录信息，因此RecyclerView控件并未显示任何内容，在完成备忘录添加功能之后，再来完善本页面的功能代码。
(4) 运行程序，效果如图5.14所示。


图5.14主界面设计效果图


【任务53】使用SQLite数据库实现信息添加
(1) 设计第三个Activity的布局界面。双击layout文件夹下的activity_ add_info.xml文件，便可打开布局编辑器，修改布局类型为LinearLayout，添加方向属性为vertical。依次添加所需控件，代码如下。



<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"


android:orientation="vertical"

android:background="@drawable/bgthree"

tools:context=".AddInfoActivity">




<EditText

android:id="@+id/editText_title"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:hint="备忘录的标题"

android:textStyle="bold"

android:textColor="#000000"

android:textSize="30sp"/>

<View

android:layout_width="match_parent"

android:layout_height="2dp"

android:background="#009688"

android:layout_marginTop="-10dp"/>

<EditText

android:id="@+id/editText_content"

android:layout_width="match_parent"

android:layout_height="200dp"

android:hint="备忘录的内容"

android:textStyle="bold"

android:textColor="#000000"

android:textSize="20sp"

android:gravity="top"/>

<View

android:layout_width="match_parent"

android:layout_height="2dp"

android:background="#009688"

android:layout_marginTop="-10dp"/>

<TextView

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:text="请选用下面的任一种方式，添加一张心情图片:"

android:textStyle="bold"

android:textColor="#000000"

android:textSize="15sp"

android:gravity="top"

android:layout_margin="10dp"/>

<LinearLayout

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:orientation="horizontal"

android:layout_margin="10dp">

<Button

android:id="@+id/button_camera"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="拍照"


android:textStyle="bold"

android:textColor="#000000"

android:textSize="15sp"

android:layout_margin="10dp"/>




<Button

android:id="@+id/button_photo"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="从图库中选择"

android:textStyle="bold"

android:textColor="#000000"

android:textSize="15sp"

android:layout_margin="10dp"/>

</LinearLayout>

<ImageView

android:id="@+id/imageView_preview"


android:layout_width="wrap_content"

android:layout_height="200dp"

android:src="@drawable/sunshine"

android:layout_marginBottom="20dp"

android:layout_gravity="center"/>

<Button

android:id="@+id/button_save"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:text="保存"

android:textStyle="bold"

android:textColor="#000000"

android:textSize="30sp"

android:background="@drawable/savebg"

android:layout_margin="10dp"/>

</LinearLayout>


上述代码中，View控件用来定义一条线，使用layout_height属性设置线的粗细，使用background属性设置线的颜色，layout_marginTop属性取值为-10的目的是想让这条线与EditText控件输入框底边线重合，增强页面的美观效果。
(2) 创建数据库类文件。因考虑到用户会存放很多的备忘录信息，而且每条备忘录信息包含文字和图片两种不同类型的数据，因此采用SQLite数据库存放备忘录信息。为了使程序文件条理清晰，创建db文件夹来存放数据库文件。方法为： 右击com.example.mymemotest→New→Package→输入名称“db”→ OK，便可完成db文件夹的创建。然后创建数据库类文件，右击db→New→Java Class→在Name中输入类名“MyDbHelper”→ Superclass中输入父类“SQLiteOpenHelper”，会自动出现全称android.database.sqlite.SQLiteOpenHelper→OK。在数据库类文件中输入如下代码。



public class MyDbHelper extends SQLiteOpenHelper {   

//定义数据库名和数据库的版本号

private  static String DBNAME="zsmemo.db";

private  static int VERSION=1;

//构造方法

public MyDbHelper( Context context) {

super(context, DBNAME, null, VERSION);



}

//创建数据库

@Override

public void onCreate(SQLiteDatabase db) {

//创建数据表

db.execSQL("create table tb_memory(_id Integer primary key,title String (200),content String (2000),imgpath String (200),mtime String (50))");

}

//升级数据库

@Override


public void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i1) {

}


}


上述代码中，SQLiteOpenHelper是专门管理数据库的帮助类，借助于这个类就可以非常简单地对数据库进行创建和升级。SQLiteOpenHelper是一个抽象类，使用时需要创建一个自定义的帮助类去继承它。
SQLiteOpenHelper中有两个抽象方法，分别是onCreate()和onUpgrade()方法，用户必须在自定义的帮助类里面重写这两个方法，然后分别在这两个方法中去实现创建、升级数据库的逻辑。SQLiteOpenHelper中还有两个非常重要的实例方法： getWritableDatabase()和getReadableDatabase()，这两个方法用于创建或打开一个现有的数据库，并返回一个可对数据库进行读写操作的对象SQLiteDatabase。
SQLiteOpenHelper的构造方法中接收四个参数： 第一个参数是上下文环境Context； 第二个参数是数据库名； 第三个参数是查询数据的时候返回一个自定义的Cursor，一般传入null； 第四个参数是当前数据库的版本号，版本号用于对数据库进行升级操作。SQLiteDatabase的execSQL()方法创建数据表tb_memory。
(3) 添加图片加载库Glide依赖，同时添加图片缩略图路径与真实路径转换的依赖，方便第三个页面中图片控件中显示拍照图片或者显示从相册中选择的图片。打开Project/app/build.gradle文件，在dependencies闭包中添加如下内容。



dependencies {

implementation fileTree(dir: 'libs', include: ［'*.jar'］)

implementation 'com.android.support:appcompat-v7:+'

…

implementation 'com.android.support:recyclerview-v7:+'

implementation 'com.github.bumptech.glide:glide:4.9.0'

api 'com.blankj:utilcode:1.23.7'

}


(4) 实现第三个Activity页面的功能。打开AddInfoActivity.java类文件，修改AddInfoActivity的代码，具体如下。



public class AddInfoActivity extends AppCompatActivity {

//定义对象

private EditText edit_title,edit_content;





private Button btn_camera,btn_photo,btn_save;

private ImageView img_preview;

private String tmp_path,disp_path;

private MyDbHelper mhelper; 

private SQLiteDatabase db;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_add_info);

//1.绑定控件

initView();

//2.单击按钮、拍照、从图库中选择照片

btnOnClick();

//3.接受拍好照片、接受从图库当中选择的照片 ------方法：系统回调


//4.把信息保存到数据库中

btnSave();

}

//1.绑定控件

private void initView() {

edit_title=findViewById(R.id.editText_title);

edit_content=findViewById(R.id.editText_content);

btn_camera=findViewById(R.id.button_camera);

btn_photo=findViewById(R.id.button_photo);

img_preview=findViewById(R.id.imageView_preview);

btn_save=findViewById(R.id.button_save);

mhelper=new MyDbHelper(AddInfoActivity.this); //

db= mhelper.getWritableDatabase();

}

//2.单击按钮、拍照

private void btnOnClick() {

btn_camera.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//拍照

Time time=new Time();

time.setToNow();

String  randtime=time.year+(time.month+1)+time.monthDay+time.hour+time.minute+time.second+"";

tmp_path= Environment.getExternalStorageDirectory()+"/image"+ randtime+".jpg";

File imgfile=new File(tmp_path);

try {

imgfile.createNewFile();

} catch (IOException e) {

e.printStackTrace();

}

Intent intent=new Intent("android.media.action.IMAGE_CAPTURE");

intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(imgfile) );

startActivityForResult(intent,11);

}





});

//从相册中选择图片

btn_photo.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//选择照片

Intent intent=new Intent("android.intent.action.GET_CONTENT");

intent.setType("image/*");

startActivityForResult(intent,22);

}

});

}

//3.接受拍好照片、接受从图库当中选择的照片 ------方法：系统回调

@Override


protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {

switch (requestCode){

case 11:

if(resultCode==RESULT_OK){

disp_path=tmp_path;

Glide.with(AddInfoActivity.this).load(disp_path).into(img_preview);

}

break;

case 22:

Uri imageuri=data.getData();

if (imageuri==null)

{

return;

}

disp_path=UriUtils.uri2File(imageuri).getPath();

Glide.with(AddInfoActivity.this).load(disp_path).into(img_preview);

break;

default:

break;

}

}

//4.把信息保存到数据库中

private void btnSave() {

btn_save.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//保存信息到数据库代码

Time time=new Time();

time.setToNow();

ContentValues contentValues=new ContentValues();  //1行

contentValues.put("title",edit_title.getText().toString());
 //1行——title列

contentValues.put("content",edit_content.getText().toString());
 //1行——content列



contentValues.put("imgpath",disp_path); //1行——imgpath列

contentValues.put("mtime",time.year+"/"+(time.month+1)+"/"+time.monthDay);  // mtime列

db.insert("tb_memory",null,contentValues); //将该行数据保存到数据表中

Toast.makeText(AddInfoActivity.this,"保存成功",Toast.LENGTH_SHORT).show();

//跳转到主界面

Intent intent=new Intent(AddInfoActivity.this,MainActivity.class);

startActivity(intent);

finish();

}

});

}

}


上述代码中，调用摄像头拍照和从相册中选择图片的代码在5.3节中已学习过，这里不再重复讲解，需要说明的是，本页面是如何把数据保存到数据库中的呢？首先定义数据库帮助类MyDbHelper和数据库类SQLiteDatabase； 其次调用new MyDbHelper(AddInfoActivity.this)语句实例化数据库帮助类，对象名为mhelper，调用数据库帮助类的getWritableDatabase()方法获得SQLiteDatabase数据库对象，对象名为db，借助于SQLiteDatabase对象就可以对数据库中的数据表进行增删改查操作了。
本页面主要实现了向数据库中tb_memory数据表添加数据，首先调用new ContentValues()方法构建一行数据，其次采用put()方法将用户输入的备忘录标题放到title列、备忘录内容放到content列、心情图片路径放到imgpath列、添加备忘录的时间放到mtime列，最后调用数据库的insert()方法将本行数据保存到数据表中。数据保存结束后跳转到主界面，及时查看添加的备忘录信息。
(5) 声明权限。双击打开AndroidManifest.xml配置文件，具体代码如下。



<manifest xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:tools="http://schemas.android.com/tools"

package="com.example.filesavetest">

<uses-permission android:name="android.permission.CAMERA"/>

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>



<application

…


上述代码指定了当前SD卡具有可写可读的权限，同时指定了本程序具有访问系统相机的权限，因此应用程序不仅可以打开系统相机拍照，而且还可以操作SD卡中的图片文件。

(6) 信息添加页面完成后，运行程序，在页面中输入标题、内容、图片等数据内容，单击“保存”按钮完成数据的添加。效果如图5.15(a)所示。
(7) 查看保存在数据库中的信息。在模拟器中打开RE文件管理器，挂载为可读写模式，根据存储路径依次操作： data/data/com.example.mymemotest/databases/zsmemo.db/tb_memory，双击tb_memory数据表将其打开，看到了保存的数据信息，效果如图5.15(b)所示。用户可以将模拟器切换到横屏模式查看完整的数据表字段。


图5.15信息添加界面及查看存储的数据


【任务54】读取SQLite数据库中数据显示到备忘录主界面
RecyclerView控件显示数据时，需要提前准备好数据、item子布局、适配器、布局管理器。①数据： 由于RecyclerView是滚动列表，可显示大量数据，因此一般会用List来存放RecyclerView控件所需要的数据。②item子布局： RecyclerView显示数据时，每一行都是一个item，该行中的文字和图片排放位置如何，大小间距如何，都需要通过item子布局来设定每行数据显示的外观。③适配器： 要将List中的数据以item子布局的外观样式显示出来，那么就需要在数据和子布局之间架起一座桥梁，这个桥梁即为适配器，通过适配器来控制数据以子布局设定的外观样式展示给用户。④布局管理器： RecyclerView中的数据既可以横向滚动，又可以纵向滚动，用户可根据需要挑选RecyclerView控件的布局管理器。

(1) 新建数据类MemoBean。为了让RecyclerView能够显示很多数据，定义List动态数组列表来存放数据，List列表支持单一数据类型，不能把文字和图片两种不同类型的数据单独放到里面，此时需要把备忘录标题、备忘录内容、心情图片三个数据封装成一个类，以List<MemoBean> arr1方式定义列表。这种数据类MemoBean有一个特殊的统称，被称为标准的JavaBean。为了使程序条理清晰，创建bean文件夹来存放JavaBean类文件。方法为： 右击com.example.mymemotest→New→Package→输入名称“bean”→OK，便可完成bean文件夹的创建。然后创建JavaBean类文件，右击bean→New→Java Class→在Name中输入类名“MemoBean”→OK。双击MemoBean类文件将其打开，输入如下代码。



public class MemoBean {

//定义四个属性

private String title;

private String content;

private String imgpath;

private String time;

//按Alt+Insert组合键，选择Contructor构造方法，全选四个属性，单击OK按钮

public MemoBean(String title, String content, String imgpath, String time) {

this.title = title;

this.content = content;

this.imgpath = imgpath;

this.time = time;

}


//按Alt+Insert组合键，选择Getter and Setter方法，全选四个属性，单击OK按钮

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}

public String getContent() {

return content;

}

public void setContent(String content) {

this.content = content;

}

public String getImgpath() {

return imgpath;

}

public void setImgpath(String imgpath) {

this.imgpath = imgpath;

}

public String getTime() {

return time;

}

public void setTime(String time) {

this.time = time;

}

}


上述代码中，在MemoBean类文件中定义了四个属性，分别是title、content、imgpath、time，这四个属性正好是List动态数组中要存放的四个数据，也是主页面RecyclerView控件中需要显示的内容，同时还是数据库tb_memory数据表里的四列字段名。
(2) 新建RecyclerView子布局。在子布局中明确标题、内容和图片的位置关系。将工程依次展开为app→src→main→res→layout，右击layout→new→Layout resource file→file name输入“recy_item”→OK，双击打开recy_item.xml布局文件，修改布局代码如下。




<?xml version="1.0" encoding="utf-8"?>

<LinearLayout

xmlns:android="http://schemas.android.com/apk/res/android"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:orientation="horizontal"

android:background="#7AECCC"

android:id="@+id/item_layout"

android:layout_margin="5dp" >

<LinearLayout

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:orientation="vertical"

android:layout_gravity="center"


android:layout_weight="1"

android:layout_margin="5dp"  >

<TextView

android:id="@+id/item_title"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:text="标题"

android:textSize="20sp"

android:textStyle="bold"

android:textColor="#000000"/>

<TextView

android:id="@+id/item_content"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="内容"

android:textColor="#000000"/>

</LinearLayout>

<LinearLayout

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:orientation="vertical"

android:layout_margin="5dp">

<ImageView

android:id="@+id/item_image"

android:layout_width="100dp"

android:layout_height="100dp"

android:src="@mipmap/ic_launcher_round"/>

<TextView

android:id="@+id/item_time"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="时间"

android:textColor="#000000"

android:layout_gravity="center"/>

</LinearLayout>

</LinearLayout>


上述代码中，子布局总体采用水平方向线性布局，左侧嵌套垂直方向线性布局用来显示标题和内容，右侧嵌套垂直方向的线性布局，用来显示图片和日期，如图5.16所示。


图5.16RecyclerView控件的子布局item


(3) 建立RecyclerView适配器MemoAdapter。为了让JavaBean中数据能够以recy_item子布局的外观样式显示到RecyclerView控件上，需要在数据与子布局之间搭建一个桥梁，即适配器。为了使程序文件条理清晰，创建adapter文件夹来存放适配器类文件。方法为： 右击com.example.mymemotest→New→Package→输入名称“adapter”→OK，便可完成adapter文件夹的创建。然后创建JavaBean类文件，右击bean→New→Java Class→Name中输入类名“MemoAdapter”→Superclass中输入父类“RecyclerView.Adapter”，会自动出现全称android.support.v7.widget.RecyclerView.Adapter→OK。在适配器类文件中输入如下代码。



//1.类文件后面添加泛型

//2.鼠标定位类文件行红色波浪线处，按Alt+Enter组合键：添加未实现的方法

//3.鼠标定位类文件行ViewHolder处，按Alt+Enter组合键：添加内部类

//4.鼠标定位界面最下方内部类ViewHolder处，添加extends  RecyclerView.ViewHolder

//5.鼠标定位界面最下方内部类ViewHolder红色波浪线处，按Alt+Enter组合键：添加构造方法

//6.定义两个对象：上下文环境和数组

//7.定义两个对象下方的空白处：Alt+Insert键，添加适配器的构造方法

public class MemoAdapter extends RecyclerView.Adapter<MemoAdapter.ViewHolder> {

private Context mcontext;

private List<MemoBean> arr1;

public MemoAdapter(Context mcontext, List<MemoBean> arr1) {

this.mcontext = mcontext;

this.arr1 = arr1;

}

//负责加载item布局

@NonNull

@Override

public MemoAdapter.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int i) {

View view= LayoutInflater.from(mcontext).inflate(R.layout.recy_item,parent,false);

ViewHolder mholder=new ViewHolder(view);

return mholder;

}

//负责加载item的数据

@Override

public void onBindViewHolder(@NonNull MemoAdapter.ViewHolder mholder, int i) {

final MemoBean memoBean=arr1.get(i);

mholder.item_title.setText(memoBean.getTitle());




mholder.item_content.setText(memoBean.getContent());

mholder.item_time.setText(memoBean.getTime());

Glide.with(mcontext).load(memoBean.getImgpath()).into(mholder.item_img);

}

//recyView一共有多少个子项

@Override

public int getItemCount() {

return arr1.size();

}

public class ViewHolder  extends  RecyclerView.ViewHolder {

TextView item_title,item_content,item_time;

ImageView item_img;

LinearLayout item_layout;

public ViewHolder(@NonNull View itemView) {

super(itemView);

item_title=itemView.findViewById(R.id.item_title);

item_content=itemView.findViewById(R.id.item_content);

item_img=itemView.findViewById(R.id.item_image);

item_time=itemView.findViewById(R.id.item_time);

item_layout=itemView.findViewById(R.id.item_layout);

}

}

}


上述代码中，最下方首先定义了一个内部类ViewHolder，ViewHolder要继承自RecyclerView.ViewHolder。然后在ViewHolder的构造方法中传入一个itemView参数，这个参数就是RecyclerView子项的最外层布局，通过itemView.findViewById方法获取布局中的TextView和ImageView及LinearLayout控件的实例。
由于MemoAdapter继承了RecyclerView.Adapter，那么就必须重写3个方法。onCreateViewHolder()方法是用户创建ViewHolder实例的，在这个方法中把recy_item子布局加载进来。onBindViewHolder()方法用于对RecyclerView子项进行赋值，根据子项的位置i得到当前项的MemoBean实例，然后再将数据显示到对应的控件上。getItem()方法用于告诉RecyclerView一共有多少子项，直接返回数据源数组的长度即可。
(4) 完善MainActivity页面的功能，实现备忘录信息的展示。打开MainActivity.java类文件，修改MainActivity的代码如下。



public class MainActivity extends AppCompatActivity {

//定义对象

private Button btn_add;

private RecyclerView recy_view;

private MyDbHelper mhelper;

SQLiteDatabase db;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);



//1.绑定控件

initView();

//2.对按钮添加单击事件

btnonclicknext();

//3.完善：从数据库获取数据，显示到RecyclerView控件中

recyDisplay();

}

//1.绑定控件

private void initView() {

btn_add=findViewById(R.id.button_add);

recy_view=findViewById(R.id.recy_view);

mhelper=new MyDbHelper(MainActivity.this);

db=mhelper.getWritableDatabase();


}

//2.对按钮添加单击事件

private void btnonclicknext() {

btn_add.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//单击后跳转到下一页

Intent intent=new Intent(MainActivity.this,AddInfoActivity.class);

startActivity(intent);

finish();

}

});

}

//3.完善：从数据库获取数据，显示到RecyclerView控件中

private void recyDisplay() {

//3.1准备数据-----------标题、内容、图片、时间(类)

List<MemoBean> arr=new ArrayList();

//从数据库中取数据

Cursor  cursor=db.rawQuery("select * from tb_memory",null);

while(cursor.moveToNext()){

String mytitle=cursor.getString(cursor.getColumnIndex("title"));

String mycontent=cursor.getString(cursor.getColumnIndex("content"));

String myimgpath=cursor.getString(cursor.getColumnIndex("imgpath"));

String mymtime=cursor.getString(cursor.getColumnIndex("mtime"));

MemoBean memoBean=new MemoBean(mytitle,mycontent,myimgpath,mymtime);

arr.add(memoBean);

}

cursor.close();

//3.2 子布局 recy_item

//3.3 数据------桥(适配器MemoAdapter)----------------子布局

MemoAdapter adapter=new MemoAdapter(MainActivity.this,arr);

//3.4 确定显示的方式

StaggeredGridLayoutManager st=new StaggeredGridLayoutManager(2,StaggeredGridLayoutManager.VERTICAL);

recy_view.setLayoutManager(st);

//3.5 让数据显示出来



recy_view.setAdapter(adapter);

}

}


(5) 备忘录删除功能的实现。单击页面上的某一个备忘录内容，在弹出的对话框中单击“删除”按钮，便可删除备忘录信息，同时刷新RecyclerView信息列表以显示最新的备忘录内容。修改每条备忘录的背景颜色，采用随机数字的方式设置背景颜色，同时设置item为圆角矩形。双击打开MemoAdapter适配器，在onBindViewHolder()方法中完善代码，具体如下。



public class MemoAdapter extends RecyclerView.Adapter<MemoAdapter.ViewHolder> {

private Context mcontext;


private List<MemoBean> arr1;

private MyDbHelper mhelper1;

private SQLiteDatabase db;



…//中间的这部分代码保持不变



//负责加载item的数据

@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)

@Override

public void onBindViewHolder(@NonNull MemoAdapter.ViewHolder mholder, final int i) {

final MemoBean memoBean=arr1.get(i);

mholder.item_title.setText(memoBean.getTitle());

mholder.item_content.setText(memoBean.getContent());

mholder.item_time.setText(memoBean.getTime());

Glide.with(mcontext).load(memoBean.getImgpath()).into(mholder.item_img);



//完善：设置RecyclerView中每一个子项的颜色和形状

Random random = new Random();

int color = Color.argb(255, random.nextInt(256), random.nextInt(256), random.nextInt(256));

GradientDrawable gradientDrawable = new GradientDrawable();

gradientDrawable.setShape(GradientDrawable.RECTANGLE);   //形状

gradientDrawable.setCornerRadius(10f);   //设置圆角Radius

gradientDrawable.setColor(color);   //颜色

mholder.item_layout.setBackground(gradientDrawable);   //设置为background



//完善：单击其中的一个子项，弹出删除功能

mholder.item_layout.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View view) {

//弹出对话框，删除

AlertDialog.Builder dialog=new AlertDialog.Builder(mcontext);

dialog.setMessage("确定删除吗？");

dialog.setPositiveButton("确定", new DialogInterface.OnClickListener() {

@Override

public void onClick(DialogInterface dialogInterface, int abc) {



//从数据库当中删除掉

mhelper1= new MyDbHelper(mcontext);

db=mhelper1.getWritableDatabase();

db.delete("tb_memory","title=?",new String［］{arr1.get(i).getTitle
()});   //删除

arr1.remove(i);   //从list动态数组中把该项移除

notifyItemRemoved(i);   //刷新RecyclerView显示的内容

dialogInterface.dismiss();  //对话框消失

}

});

dialog.setNegativeButton("取消",null);


dialog.setCancelable(false);

dialog.create();

dialog.show();

}

});



}

…//后面的代码保持不变

…


(6) 运行程序，单击第一条备忘录，弹出对话框，单击“确定”按钮便将该条备忘录删除，RecyclerView会及时刷新并显示最新数据，效果如图5.17所示。


图5.17备忘录数据的删除


项目小结
本项目内容紧紧围绕Android中的SharedPreferences存储、Android的文件存储、调用摄像头和相册以及运行时权限设置内容来展开，使用户根据存储数据的特点选择不同的存储方式，能够将拍摄的图片根据需要随时存放到内存或外存中。通过学习Android运行时权限，保障了用户的信息安全。最后，通过备忘录案例，培养学生具备复杂App的设计与开发能力。
习题
1. SharedPreferences所存储的数据以()的格式保存在XML文件中。

A. “姓名”B. “键值”C. 文件D. 字符
2. Android的几种存储方式中，（）是以键值对的方式来存储数据的。
A. SharedPreferences存储B. 文件存储
C. SQLite数据库存储D. SD卡存储
3. getSharedPreferences("myfile",0)方法中的第二个参数0表示以追加模式保存数据。()
A. 对B.错 
4. Android提供了标准的Java文件()方式来对文件数据进行读写。
A. “姓名”B. “键值”C. 字符D. 输入输出流
5. Context类的（）方法可以获得文件输入流对象。
A. openFileOutputB. openFileInput
6. 下面（）方法是关闭文件输入/输出流的方法。
A. close()B. exit()
7. 打开摄像头和相册的系统页面，属于()跳转。
A. 显式跳转B. 隐式跳转
8. 下面（）可以打开摄像头。
A. android.media.action.IMAGE_CAPTURE
B. android.intent.action.GET_CONTENT 
9. 在Android项目中，图片加载库有很多选择，常用的是()。
A. GlideB. ImageC. pictureD. icon
10. 下面（）控件不能直接使用，需要添加()依赖才可使用。

A. ImageViewB. TextView
C. EditTextD. RecyclerView