Android中操作数据的集中方式---文件，SQLite，ContentProvider

最新推荐文章于 2021-05-31 21:22:53 发布
最新推荐文章于 2021-05-31 21:22:53 发布
阅读量2.4k 收藏 4
点赞数
分类专栏： Android开发详解 文章标签： listview android应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he90227/article/details/33734239
版权

Android中的文件存储数据方式

1.文件存储数据使用了Java中的IO操作来进行文件的保存和读取，只不过Android在Context类中封装好了输入流和输出流的获取方法。
创建的存储文件保存在/data/data/<package name>/files文件夹下。

 

 

2.操作。
保存文件内容：通过Context.openFileOutput获取输出流，参数分别为文件名和存储模式。
读取文件内容：通过Context.openFileInput获取输入流，参数为文件名。
删除文件：Context.deleteFile删除指定的文件，参数为将要删除的文件的名称。
获取文件名列表：通过Context.fileList获取files目录下的所有文件名数组。
*获取文件路径的方法：
绝对路径：/data/data/<package name>/files/filename
Context：Context.getFilesDir()可以获取到"/data/data/<package name>/files"

 

3.四种文件保存的模式。
Context.MODE_PRIVATE 为默认操作模式，代表该文件是私有数据，只能被应用本身访问，在该模式下写入的内容会覆盖原文件的内容。
Context.MODE_APPEND 检查文件是否存在，存在就往文件追加内容，否则就创建新文件。
MODE_WORLD_READABLE 表示当前文件可以被其他应用读取。
MODE_WORLD_WRITEABLE 表示当前文件可以被其他应用写入。
在使用模式时，可以用"+"来选择多种模式，比如openFileOutput(FILENAME, Context.MODE_PRIVATE + MODE_WORLD_READABLE);

 

下面通过程序来演示下文件存储的使用。完整代码下载：android_files.rar

[java]  view plain copy
  1. /** 
  2.  * MainActivity 
  3.  *  
  4.  * @author zuolongsnail 
  5.  *  
  6.  */  
  7. public class MainActivity extends Activity {  
  8.     private EditText writeET;  
  9.     private Button writeBtn;  
  10.     private TextView contentView;  
  11.     public static final String FILENAME = "setting.set";  
  12.   
  13.     @Override  
  14.     public void onCreate(Bundle savedInstanceState) {  
  15.         super.onCreate(savedInstanceState);  
  16.         setContentView(R.layout.main);  
  17.         writeET = (EditText) findViewById(R.id.write_et);  
  18.         writeBtn = (Button) findViewById(R.id.write_btn);  
  19.         contentView = (TextView) findViewById(R.id.contentview);  
  20.         writeBtn.setOnClickListener(new OperateOnClickListener());  
  21.     }  
  22.   
  23.     class OperateOnClickListener implements OnClickListener {  
  24.         @Override  
  25.         public void onClick(View v) {  
  26.             writeFiles(writeET.getText().toString());  
  27.             contentView.setText(readFiles());  
  28.             System.out.println(getFilesDir());  
  29.         }  
  30.     }  
  31.   
  32.     // 保存文件内容  
  33.     private void writeFiles(String content) {  
  34.         try {  
  35.             // 打开文件获取输出流，文件不存在则自动创建  
  36.             FileOutputStream fos = openFileOutput(FILENAME,  
  37.                     Context.MODE_PRIVATE);  
  38.             fos.write(content.getBytes());  
  39.             fos.close();  
  40.         } catch (Exception e) {  
  41.             e.printStackTrace();  
  42.         }  
  43.     }  
  44.   
  45.     // 读取文件内容  
  46.     private String readFiles() {  
  47.         String content = null;  
  48.         try {  
  49.             FileInputStream fis = openFileInput(FILENAME);  
  50.             ByteArrayOutputStream baos = new ByteArrayOutputStream();  
  51.             byte[] buffer = new byte[1024];  
  52.             int len = 0;  
  53.             while ((len = fis.read(buffer)) != -1) {  
  54.                 baos.write(buffer, 0, len);  
  55.             }  
  56.             content = baos.toString();  
  57.             fis.close();  
  58.             baos.close();  
  59.         } catch (Exception e) {  
  60.             e.printStackTrace();  
  61.         }  
  62.         return content;  
  63.     }  
  64. }  

程序截图：

 

提供一个文件存储数据的工具类：

[java]  view plain copy
  1. /** 
  2.  * 文件存储数据方式工具类 
  3.  *  
  4.  * @author zuolongsnail 
  5.  */  
  6. public class FilesUtil {  
  7.     /** 
  8.      * 保存文件内容 
  9.      *  
  10.      * @param c 
  11.      * @param fileName 
  12.      *            文件名称 
  13.      * @param content 
  14.      *            内容 
  15.      */  
  16.     private void writeFiles(Context c, String fileName, String content, int mode)  
  17.             throws Exception {  
  18.         // 打开文件获取输出流，文件不存在则自动创建  
  19.         FileOutputStream fos = c.openFileOutput(fileName, mode);  
  20.         fos.write(content.getBytes());  
  21.         fos.close();  
  22.     }  
  23.   
  24.     /** 
  25.      * 读取文件内容 
  26.      *  
  27.      * @param c 
  28.      * @param fileName 
  29.      *            文件名称 
  30.      * @return 返回文件内容 
  31.      */  
  32.     private String readFiles(Context c, String fileName) throws Exception {  
  33.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
  34.         FileInputStream fis = c.openFileInput(fileName);  
  35.         byte[] buffer = new byte[1024];  
  36.         int len = 0;  
  37.         while ((len = fis.read(buffer)) != -1) {  
  38.             baos.write(buffer, 0, len);  
  39.         }  
  40.         String content = baos.toString();  
  41.         fis.close();  
  42.         baos.close();  
  43.         return content;  
  44.     }  
  45. }  

 

SQLite的使用


Android中的数据库存储是直接使用了SQLite。在Android应用中创建数据库后数据库文件是存储在/data/ data/应用包名/databases/下。

 

在Android中使用到SQLite会涉及到以下三个类或接口：
1.SQLiteOpenHelper
*SQLiteOpenHelper 构造方法，一般传递一个要创建的数据库名称name参数
*onCreate 创建数据库时调用
*onUpgrade 版本更新时调用
*getReadableDatabase 创建或打开一个只读数据库
*getWritableDatabase 创建或打开一个读写数据库

2.SQLiteDatabase
*openOrCreateDatabase 打开或者创建数据库
*insert 添加一条记录
*delete 删除一条记录
*query 查询记录
*update 更新记录
*execSQL 执行一条SQL语句
*close 关闭数据库

3.Cursor
*getCount 总记录条数
*isFirst 判断是否第一条记录
*isLast 判断是否最后一条记录
*moveToFirst 移动到第一条记录
*moveToLast 移动到最后一条记录
*move 移动到指定记录
*moveToNext 移动到下一条记录
*moveToPrevious 移动到上一条记录
*getColumnIndexOrThrow根据列名称获得列索引
*getInt 获得指定列索引的int类型值
*getString 获得指定列索引的String类型值
注：某些方法是有重载的，可以结合docs熟悉下。

 

下面贴上数据库操作的代码，完整代码下载地址：android_sqlite.rar

1.创建数据库只要自定义一个类继承SQLiteOpenHelper即可。在SQLiteOpenHelper的子类中至少需要实现三个方法：
*构造方法，调用父类SQLiteOpenHelper的构造函数。需要四个参数：上下文环境（例如一个Activity）；数据库名称；一个可选的游标工厂（通常是null）；一个正在使用的数据库版本。
*onCreate方法，需要一个SQLiteDatabase对象作为参数，根据需要对这个对象填充表和初始化数据。
*onUpgrade方法，需要三个参数：一个SQLiteDatabase对象，一个旧的版本号和一个新的版本号。

[java]  view plain copy
  1. /** 
  2.  * 数据库操作助手类 
  3.  *  
  4.  * @author zuolongsnail 
  5.  */  
  6. public class AndroidSQLiteOpenHelper extends SQLiteOpenHelper {  
  7.   
  8.     // 数据库名称  
  9.     public static final String DBNAME = "android.db";  
  10.     // 数据库版本  
  11.     public static final int VERSION = 2;  
  12.     // 建表语句，大小写不敏感  
  13.     private static final String CREATETABLE = "create table "  
  14.             + Person.TABLENAME  
  15.             + "(id string, name string, gender int, age int)";  
  16.   
  17.     public AndroidSQLiteOpenHelper(Context context) {  
  18.         super(context, DBNAME, null, VERSION);  
  19.     }  
  20.   
  21.     // 创建表  
  22.     @Override  
  23.     public void onCreate(SQLiteDatabase db) {  
  24.         db.execSQL(CREATETABLE);  
  25.     }  
  26.   
  27.     // 更新表  
  28.     @Override  
  29.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
  30.         this.deleteDB(db);  
  31.         this.onCreate(db);  
  32.     }  
  33.   
  34.     // 删除表  
  35.     private void deleteDB(SQLiteDatabase db) {  
  36.         db.execSQL("drop table if exists " + Person.TABLENAME);  
  37.     }  
  38. }  

2.对数据库表进行操作，包括添加、删除、修改和查询。（下面的代码使用的是第一种方法）
有两种方法可以对数据库表进行操作：使用execSQL方法执行SQL语句；使用insert、delete、update和query方法，把SQL语句的一部分作为参数。
注：查询数据库时执行SQL语句是使用SQLiteDatabase的rawQuery方法而不是execSQL。 

[java]  view plain copy
  1. /** 
  2.  * 数据库管理类 
  3.  *  
  4.  * @author zuolongsnail 
  5.  *  
  6.  */  
  7. public class DatabaseManager {  
  8.   
  9.     private AndroidSQLiteOpenHelper dbHelper;  
  10.   
  11.     public DatabaseManager(Context context) {  
  12.         dbHelper = new AndroidSQLiteOpenHelper(context);  
  13.     }  
  14.   
  15.     // 插入记录  
  16.     public int insert(Person person) {  
  17.         Log.e("SQLite", "----insert----");  
  18.         SQLiteDatabase db = dbHelper.getWritableDatabase();  
  19.         db.beginTransaction();  
  20.         try {  
  21.             db.execSQL("insert into " + Person.TABLENAME  
  22.                     + " values(?, ?, ?, ?)", new Object[] { person.id,  
  23.                     person.name, person.gender, person.age });  
  24.             db.setTransactionSuccessful();  
  25.         } catch (Exception e) {  
  26.             return 0;  
  27.         } finally {  
  28.             db.endTransaction();  
  29.         }  
  30.         db.close();  
  31.         return 1;  
  32.     }  
  33.   
  34.     // 删除记录  
  35.     public int delete(Person person) {  
  36.         Log.e("SQLite", "----delete----");  
  37.         SQLiteDatabase db = dbHelper.getWritableDatabase();  
  38.         db.beginTransaction();  
  39.         try {  
  40.             db.execSQL("delete from " + Person.TABLENAME + " where id = ?",  
  41.                     new Object[] { person.id });  
  42.             db.setTransactionSuccessful();  
  43.         } catch (Exception e) {  
  44.             return 0;  
  45.         } finally {  
  46.             db.endTransaction();  
  47.         }  
  48.         db.close();  
  49.         return 1;  
  50.     }  
  51.   
  52.     // 更新记录  
  53.     public int update(Person person) {  
  54.         Log.e("SQLite", "----update----");  
  55.         SQLiteDatabase db = dbHelper.getWritableDatabase();  
  56.         db.beginTransaction();  
  57.         try {  
  58.             db.execSQL("update " + Person.TABLENAME  
  59.                     + " set name=?, gender=?, age=? where id=?", new Object[] {  
  60.                     person.name, person.gender, person.age, person.id });  
  61.             db.setTransactionSuccessful();  
  62.         } catch (Exception e) {  
  63.             return 0;  
  64.         } finally {  
  65.             db.endTransaction();  
  66.         }  
  67.         db.close();  
  68.         return 1;  
  69.     }  
  70.   
  71.     // 查询记录  
  72.     public ArrayList<Person> query(String id) {  
  73.         Log.e("SQLite", "----query----");  
  74.         SQLiteDatabase db = dbHelper.getReadableDatabase();  
  75.         Cursor cursor;  
  76.         Person person;  
  77.         ArrayList<Person> list = new ArrayList<Person>();  
  78.         // 若fileId为null或""则查询所有记录  
  79.         if (id == null || id.equals("")) {  
  80.             cursor = db.rawQuery("select * from " + Person.TABLENAME, null);  
  81.         } else {  
  82.             cursor = db.rawQuery("select * from " + Person.TABLENAME  
  83.                     + " where id=?", new String[] { id });  
  84.         }  
  85.         while (cursor.moveToNext()) {  
  86.             person = new Person();  
  87.             person.id = cursor.getString(cursor.getColumnIndex("id"));  
  88.             person.name = cursor.getString(cursor.getColumnIndex("name"));  
  89.             person.gender = cursor.getString(cursor.getColumnIndex("gender"));  
  90.             person.age = cursor.getInt(cursor.getColumnIndex("age"));  
  91.             Log.e("SQLite", person.toString());  
  92.             list.add(person);  
  93.         }  
  94.         cursor.close();  
  95.         db.close();  
  96.         if (list.size() == 0) {  
  97.             Log.e("SQLite", "****表中无数据****");  
  98.         }  
  99.         return list;  
  100.     }  
  101. }  

3.在shell中进入sqlite并使用sql语句操作数据库，如下图所示。

*启动命令行，执行adb shell命令，前提是启动了一个模拟器。

 

*进入/data/ data/应用包名/databases文件夹下，我们这里是/data/data/code.sqlite/databases（确保此应用已经建立数据库，不然包名下是没有databases目录的）。

*查看databases目录下的数据库文件，这里可以看到数据库文件是android.db。

*使用sqlite3命令进入sqlite来使用sql语句操作数据库，我们执行"sqlite3 android.db"命令。

*使用".tables"命令查询数据库下有哪些表。可见我们这里有一张person表。

*使用sql语句可以操作这张表，比如我们使用"select * from person;"可以查询到表中记录。

*使用".quit"命令可以退出sqlite。


Android中ContentProvider组件详解


ContentProvider（内容提供者）是Android中的四大组件之一。主要用于对外共享数据，也就是通过ContentProvider把应用中的数据共享给其他应用访问，其他应用可以通过ContentProvider对指定应用中的数据进行操作。ContentProvider分为系统的和自定义的，系统的也就是例如联系人，图片等数据。

 

以下这段是Google Doc中对ContentProvider的大致概述。
内容提供者将一些特定的应用程序数据供给其它应用程序使用。数据可以存储于文件系统、SQLite数据库或其它方式。内容提供者继承于ContentProvider 基类，为其它应用程序取用和存储它管理的数据实现了一套标准方法。然而，应用程序并不直接调用这些方法，而是使用一个 ContentResolver 对象，调用它的方法作为替代。ContentResolver可以与任意内容提供者进行会话，与其合作来对所有相关交互通讯进行管理。

 

1.ContentProvider
Android提供了一些主要数据类型的ContentProvider，比如音频、视频、图片和私人通讯录等。可在android.provider包下面找到一些Android提供的ContentProvider。通过获得这些ContentProvider可以查询它们包含的数据，当然前提是已获得适当的读取权限。
主要方法：
public boolean onCreate() 在创建ContentProvider时调用
public Cursor query(Uri, String[], String, String[], String) 用于查询指定Uri的ContentProvider，返回一个Cursor
public Uri insert(Uri, ContentValues) 用于添加数据到指定Uri的ContentProvider中
public int update(Uri, ContentValues, String, String[]) 用于更新指定Uri的ContentProvider中的数据
public int delete(Uri, String, String[]) 用于从指定Uri的ContentProvider中删除数据
public String getType(Uri) 用于返回指定的Uri中的数据的MIME类型
*如果操作的数据属于集合类型，那么MIME类型字符串应该以vnd.android.cursor.dir/开头。
例如：要得到所有person记录的Uri为content://contacts/person，那么返回的MIME类型字符串为"vnd.android.cursor.dir/person"。
*如果要操作的数据属于非集合类型数据，那么MIME类型字符串应该以vnd.android.cursor.item/开头。
例如：要得到id为10的person记录的Uri为content://contacts/person/10，那么返回的MIME类型字符串应为"vnd.android.cursor.item/person"。

 

2.ContentResolver
当外部应用需要对ContentProvider中的数据进行添加、删除、修改和查询操作时，可以使用ContentResolver类来完成，要获取ContentResolver对象，可以使用Context提供的getContentResolver()方法。

[java]  view plain copy
  1. ContentResolver cr = getContentResolver();  

ContentResolver提供的方法和ContentProvider提供的方法对应的有以下几个方法。
public Uri  insert(Uri uri, ContentValues values) 用于添加数据到指定Uri的ContentProvider中。
public int  delete(Uri uri, String selection, String[] selectionArgs) 用于从指定Uri的ContentProvider中删除数据。
public int  update(Uri uri, ContentValues values, String selection, String[] selectionArgs) 用于更新指定Uri的ContentProvider中的数据。
public Cursor  query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) 用于查询指定Uri的ContentProvider。

 

3.Uri
Uri指定了将要操作的ContentProvider，其实可以把一个Uri看作是一个网址，我们把Uri分为三部分。
第一部分是"content://"。可以看作是网址中的"http://"。
第二部分是主机名或authority，用于唯一标识这个ContentProvider，外部应用需要根据这个标识来找到它。可以看作是网址中的主机名，比如"blog.csdn.net"。
第三部分是路径名，用来表示将要操作的数据。可以看作网址中细分的内容路径。

 

下面是用ContentProvider读取联系人数据，属于系统数据。完整代码下载：android_contentprovider_system.rar

注意：这里的联系人操作有点乱，关键是我还不是很熟，SDK1.6和SDK2.1的联系人操作很有很大不同，希望哪位大侠指点一下。

[java]  view plain copy
  1. /** 
  2.  * MainActivity 
  3.  *  
  4.  * @author zuolongsnail 
  5.  */  
  6. public class MainActivity extends Activity {  
  7.     private EditText nameET;  
  8.     private EditText numberET;  
  9.     private Button insertBtn;  
  10.     private Button deleteBtn;  
  11.     private Button queryBtn;  
  12.     private ListView contentView;  
  13.   
  14.     @Override  
  15.     public void onCreate(Bundle savedInstanceState) {  
  16.         super.onCreate(savedInstanceState);  
  17.         setContentView(R.layout.main);  
  18.         nameET = (EditText) findViewById(R.id.name);  
  19.         numberET = (EditText) findViewById(R.id.number);  
  20.         insertBtn = (Button) findViewById(R.id.insert);  
  21.         deleteBtn = (Button) findViewById(R.id.delete);  
  22.         queryBtn = (Button) findViewById(R.id.query);  
  23.         // 用于显示数据  
  24.         contentView = (ListView) findViewById(R.id.content);  
  25.         insertBtn.setOnClickListener(new OperateOnClickListener());  
  26.         deleteBtn.setOnClickListener(new OperateOnClickListener());  
  27.         queryBtn.setOnClickListener(new OperateOnClickListener());  
  28.     }  
  29.   
  30.     class OperateOnClickListener implements OnClickListener {  
  31.         @Override  
  32.         public void onClick(View v) {  
  33.             String name = nameET.getText().toString();  
  34.             String number = numberET.getText().toString();  
  35.             Person p = new Person(name, number);  
  36.             switch (v.getId()) {  
  37.             // 插入数据  
  38.             case R.id.insert:  
  39.                 insert(p);  
  40.                 view();  
  41.                 break;  
  42.             // 删除数据  
  43.             case R.id.delete:  
  44.                 delete(name);  
  45.                 view();  
  46.                 break;  
  47.             // 查询数据  
  48.             case R.id.query:  
  49.                 view();  
  50.                 break;  
  51.             }  
  52.         }  
  53.     }  
  54.   
  55.     // 显示数据  
  56.     private void view() {  
  57.         Cursor c = query("");  
  58.         ListAdapter listAdapter = new SimpleCursorAdapter(this, R.layout.list,  
  59.                 c, new String[] { People._ID, People.NAME, People.NUMBER },  
  60.                 new int[] { R.id.id, R.id.name, R.id.number });  
  61.         contentView.setAdapter(listAdapter);  
  62.     }  
  63.   
  64.     // 插入联系人  
  65.     private void insert(Person p) {  
  66.         // 获得ContentResolver对象  
  67.         ContentResolver cr = getContentResolver();  
  68.         ContentValues values = new ContentValues();  
  69.         values.put(People.NAME, p.name);  
  70.         // 表示是否把联系人添加到收藏（加星），1表示加入，0表示不加入，这行代码注释默认是不加入。  
  71.         values.put(Contacts.People.STARRED, 1);  
  72.         Uri uri = Contacts.People.createPersonInMyContactsGroup(cr, values);  
  73.         // 获得联系人People表的Uri  
  74.         Uri url = Uri.withAppendedPath(uri,  
  75.                 Contacts.People.Phones.CONTENT_DIRECTORY);  
  76.         values.clear();  
  77.         values.put(Contacts.Phones.TYPE, Contacts.Phones.NUMBER);  
  78.         values.put(Contacts.Phones.NUMBER, p.number);  
  79.         // 插入操作  
  80.         cr.insert(url, values);  
  81.     }  
  82.   
  83.     // 插入联系人  
  84.     private void delete(String name) {  
  85.         // 获得ContentResolver对象  
  86.         ContentResolver cr = getContentResolver();  
  87.         Uri url = Contacts.People.CONTENT_URI;  
  88.         // 设置删除条件  
  89.         String where = People.NAME + "=?";  
  90.         String[] selectionArgs = { name };  
  91.         cr.delete(url, where, selectionArgs);  
  92.     }  
  93.   
  94.     // 查询联系人  
  95.     private Cursor query(String name) {  
  96.         // 获得ContentResolver对象  
  97.         ContentResolver cr = getContentResolver();  
  98.         Uri uri = Contacts.People.CONTENT_URI;  
  99.         // 查询对象  
  100.         String[] projection = { People._ID, People.NAME, People.NUMBER };  
  101.         // 设置查询条件，这里我把selection和selectionArgs参数都设为null，表示查询全部数据  
  102.         String selection = null;  
  103.         String[] selectionArgs = null;  
  104.         if (!"".equals(name)) {  
  105.             selection = People.NAME + "=?";  
  106.             selectionArgs = new String[] { name };  
  107.         }  
  108.         // 设置排序条件  
  109.         String sortOrder = Contacts.People._ID;  
  110.         Cursor c = cr.query(uri, projection, selection, selectionArgs,  
  111.                 sortOrder);  
  112.         // if (c.moveToFirst()) {  
  113.         // for (int i = 0; i < c.getCount(); i++) {  
  114.         // c.moveToPosition(i);  
  115.         // String name = c.getString(c.getColumnIndexOrThrow(People.NAME));  
  116.         // String number = c.getString(c  
  117.         // .getColumnIndexOrThrow(People.NUMBER));  
  118.         // }  
  119.         // }  
  120.         return c;  
  121.     }  
  122. }  

程序截图： 



Intent组件


Intent是不同组件之间相互通讯的纽带，封装了不同组件之间通讯的条件。Intent本身是定义为一个类别(Class)，一个Intent对象表达一个目的(Goal)或期望(Expectation)，叙述其所期望的服务或动作、与动作有关的数据等。Android则根据此Intent对象之叙述，负责配对，找出相配的组件，然后将 Intent对象传递给所找到的组件，Android的媒婆任务就完成了。

 

在Google Doc中是这样描述Intent的（摘自Android中文翻译组）
当接收到ContentResolver发出的请求后，内容提供者被激活。而其它三种组件──activity、服务和广播接收器被一种叫做intent的异步消息所激活。intent是一个保存着消息内容的Intent对 象。对于activity和服务来说，它指明了请求的操作名称以及作为操作对象的数据的URI和其它一些信息。比如说，它可以承载对一个activity 的请求，让它为用户显示一张图片，或者让用户编辑一些文本。而对于广播接收器而言，Intent对象指明了声明的行为。比如，它可以对所有感兴趣的对象声 明照相按钮被按下。

对于每种组件来说，激活的方法是不同的：
1.通过传递一个Intent对象至 Context.startActivity()或Activity.startActivityForResult()以载入（或指定新工作给）一个activity。相应的activity可以通过调用 getIntent() 方法来查看激活它的intent。Android通过调用activity的onNewIntent()方法来传递给它继发的intent。

一个activity经常启动了下一个。如果它期望它所启动的那个activity返回一个结果，它会以调用startActivityForResult()来取代startActivity()。比如说，如果它启动了另外一个activity以使用户挑选一张照片，它也许想知道哪张照片被选中了。结果将会被封装在一个Intent对象中，并传递给发出调用的activity的onActivityResult() 方法。

2.通过传递一个Intent对象至Context.startService()将启动一个服务（或给予正在运行的服务以一个新的指令）。Android调用服务的onStart()方法并将Intent对象传递给它。

与此类似，一个Intent可以被调用组件传递给 Context.bindService()以获取一个正在运行的目标服务的连接。这个服务会经由onBind() 方法的调用获取这个Intent对象（如果服务尚未启动，bindService()会先启动它）。比如说，一个activity可以连接至前述的音乐回放服务，并提供给用户一个可操作的（用户界面）以对回放进行控制。这个activity可以调用 bindService() 来建立连接，然后调用服务中定义的对象来影响回放。

3.应用程序可以凭借将Intent对象传递给 Context.sendBroadcast() ，Context.sendOrderedBroadcast()， 以及Context.sendStickyBroadcast()和其它类似方法来产生一个广播。Android会调用所有对此广播有兴趣的广播接收器的 onReceive()方法将intent传递给它们。

 

Intent对象包含的内容

在Intent类的Java源代码中定义了Intent相关内容的变量，如下：

[java]  view plain copy
  1. // Action  
  2. private String mAction;  
  3. // Data  
  4. private Uri mData;  
  5. private String mType;  
  6. private String mPackage;  
  7. // ComponentName  
  8. private ComponentName mComponent;  
  9. // Flag  
  10. private int mFlags;  
  11. // category  
  12. private HashSet<String> mCategories;  
  13. // extras  
  14. private Bundle mExtras;  

1.componentName（组件名称），指定Intent的目标组件的类名称。组件名称是可选的，如果填写，Intent对象会发送给指定组件名称的组件，否则也可以通过其他Intent信息定位到适合的组件。组件名称是个ComponentName类型的对象。
用法：

 

[java]  view plain copy
  1. Intent intent = new Intent();  
  2. // 构造的参数为当前Context和目标组件的类路径名  
  3. ComponentName cn = new ComponentName(HelloActivity.this, "com.byread.activity.OtherActivity");  
  4. intent.setComponent(cn);  
  5. startActivity(intent);  
相当于以下常用方法：
[java]  view plain copy
  1. Intent intent = new Intent();  
  2. intent.setClass(HelloActivity.this, OtherActivity.class);  
  3. startActivity(intent);  

Intent类中也包含一个初始化ComponentName的构造函数： 

[java]  view plain copy
  1. public Intent(Context packageContext, Class<?> cls) {  
  2.     mComponent = new ComponentName(packageContext, cls);  
  3. }  

 

2.action（动作）,指定Intent的执行动作，比如调用拨打电话组件。 

[java]  view plain copy
  1. public Intent(String action) {  
  2.     mAction = action;  
  3. }  

 

3.data（数据），起到表示数据和数据MIME类型的作用。不同的action是和不同的data类型配套的，通过设置data的Uri来获得。 

[java]  view plain copy
  1. public Intent(String action, Uri uri) {  
  2.     mAction = action;  
  3.     mData = uri;  
  4. }  

比如调用拨打电话组件：

[java]  view plain copy
  1. Uri uri = Uri.parse("tel:10086");  
  2. // 参数分别为调用拨打电话组件的Action和获取Data数据的Uri  
  3. Intent intent = new Intent(Intent.ACTION_DIAL, uri);  
  4. startActivity(intent);  

 

4.category（类别），被执行动作的附加信息。例如应用的启动Activity在intent-filter中设置category。

[xhtml]  view plain copy
  1. <intent-filter>  
  2.     <action android:name="android.intent.action.MAIN" />  
  3.     <category android:name="android.intent.category.LAUNCHER" />  
  4. </intent-filter>  

 

5.extras（附加信息），为处理Intent组件提供附加的信息。可通过putXX()和getXX()方法存取信息；也可以通过创建Bundle对象，再通过putExtras()和getExtras()方法来存取。 

 

6.flags（标记），指示Android如何启动目标Activity，设置方法为调用Intent的setFlags方法。常用的Flags参数有：

FLAG_ACTIVITY_CLEAR_TOP
FLAG_ACTIVITY_NEW_TASK
FLAG_ACTIVITY_NO_HISTORY
FLAG_ACTIVITY_SINGLE_TOP  

 

Intent的投递

1.显式方式。直接设置目标组件的ComponentName，用于一个应用内部的消息传递，比如启动另一个Activity或者一个services。
通过Intent的setComponent和setClass来制定目标组件的ComponentName。

 

2.隐式方式。ComponentName为空，用于调用其他应用中的组件。需要包含足够的信息，这样系统才能根据这些信息使用intent filter在所有的组件中过滤action、data或者category来匹配目标组件。可参考Android中Activity组件详解（5.Activity的Intent Filter）
如果Intent指明定了action，则目标组件的IntentFilter的action列表中就必须包含有这个action，否则不能匹配；
如果Intent没有提供type，系统将从data中得到数据类型。和action一样，目标组件的数据类型列表中必须包含Intent的数据类型，否则不能匹配；
如果Intent中的数据不是content: 类型的URI，而且Intent也没有明确指定它的type，将根据Intent中数据的scheme （比如 http: 或者mailto: ） 进行匹配。同上，Intent 的scheme必须出现在目标组件的scheme列表中；
如果Intent指定了一个或多个category，这些类别必须全部出现在组建的类别列表中。比如 Intent中包含了两个类别：LAUNCHER_CATEGORY 和 ALTERNATIVE_CATEGORY，解析得到的目标组件必须至少包含这两个类别。

 

Intent调用常见系统组件 

[java]  view plain copy
  1. // 调用浏览器  
  2. Uri webViewUri = Uri.parse("http://blog.csdn.net/zuolongsnail");  
  3. Intent intent = new Intent(Intent.ACTION_VIEW, webViewUri);  
  4.   
  5. // 调用地图  
  6. Uri mapUri = Uri.parse("geo:100,100");  
  7. Intent intent = new Intent(Intent.ACTION_VIEW, mapUri);  
  8.   
  9. // 播放mp3  
  10. Uri playUri = Uri.parse("file:///sdcard/test.mp3");  
  11. Intent intent = new Intent(Intent.ACTION_VIEW, playUri);  
  12. intent.setDataAndType(playUri, "audio/mp3");  
  13.   
  14. // 调用拨打电话  
  15. Uri dialUri = Uri.parse("tel:10086");  
  16. Intent intent = new Intent(Intent.ACTION_DIAL, dialUri);  
  17. // 直接拨打电话，需要加上权限<uses-permission id="android.permission.CALL_PHONE" />  
  18. Uri callUri = Uri.parse("tel:10086");  
  19. Intent intent = new Intent(Intent.ACTION_CALL, callUri);  
  20.   
  21. // 调用发邮件（这里要事先配置好的系统Email，否则是调不出发邮件界面的）  
  22. Uri emailUri = Uri.parse("mailto:zuolongsnail@163.com");  
  23. Intent intent = new Intent(Intent.ACTION_SENDTO, emailUri);  
  24. // 直接发邮件  
  25. Intent intent = new Intent(Intent.ACTION_SEND);  
  26. String[] tos = { "zuolongsnail@gmail.com" };  
  27. String[] ccs = { "zuolongsnail@163.com" };  
  28. intent.putExtra(Intent.EXTRA_EMAIL, tos);  
  29. intent.putExtra(Intent.EXTRA_CC, ccs);  
  30. intent.putExtra(Intent.EXTRA_TEXT, "the email text");  
  31. intent.putExtra(Intent.EXTRA_SUBJECT, "subject");  
  32. intent.setType("text/plain");  
  33. Intent.createChooser(intent, "Choose Email Client");  
  34.   
  35. // 发短信  
  36. Intent intent = new Intent(Intent.ACTION_VIEW);  
  37. intent.putExtra("sms_body", "the sms text");  
  38. intent.setType("vnd.android-dir/mms-sms");  
  39. // 直接发短信  
  40. Uri smsToUri = Uri.parse("smsto:10086");  
  41. Intent intent = new Intent(Intent.ACTION_SENDTO, smsToUri);  
  42. intent.putExtra("sms_body", "the sms text");  
  43. // 发彩信  
  44. Uri mmsUri = Uri.parse("content://media/external/images/media/23");  
  45. Intent intent = new Intent(Intent.ACTION_SEND);  
  46. intent.putExtra("sms_body", "the sms text");  
  47. intent.putExtra(Intent.EXTRA_STREAM, mmsUri);  
  48. intent.setType("image/png");  
  49.   
  50. // 卸载应用  
  51. Uri uninstallUri = Uri.fromParts("package", "com.app.test", null);  
  52. Intent intent = new Intent(Intent.ACTION_DELETE, uninstallUri);  
  53. // 安装应用  
  54. Intent intent = new Intent(Intent.ACTION_VIEW);  
  55. intent.setDataAndType(Uri.fromFile(new File("/sdcard/test.apk"), "application/vnd.android.package-archive");  
  56.   
  57. // 在Android Market中查找应用  
  58. Uri uri = Uri.parse("market://search?q=愤怒的小鸟");           
  59. Intent intent = new Intent(Intent.ACTION_VIEW, uri);  

注意：有的需要配置一定的权限


小飞鹤
关注
专栏目录
android 玩转ContentProvider之一－－实现ContentProvider操作数据库
jacpy的专栏
03-17 1万+
本人原创作品，谢绝转载！ 作为android四大组件之一，今天总结一下它的用法。 ContentProvider官方有很多地方提到，其中一个是在API文档上（http://developer.android.com/guide/topics/providers/content-providers.html）面有介绍，有兴趣去看一下，虽然是英文的，对了解ContentProvider很有用；还有
SQLite--SQLiteDatabase、SQLiteOpenHelper、sqlite3.c--（jni、头文件）--源码分析基于Android M
淡淡的宁静的博客
05-10 1406
open database： *使用ContextImpl#openOrCreateDatabase(),返回一个SQLiteDatabase对象。 *可以去继承SQLiteOpenHelper，然后调用getWritableDatabase（）可以获取SQLiteDatabase，使用SQLiteOpenHelper去获取，那么就要复写onCreate和onUpgrade方法。 分析SQL...
android 通过ContentProvider实现sqlite数据库共享
05-03
采用ContentProvider实现android sqlite数据库的共享，包含了本项目对数据库的访问和第三方项目（新建项目）对数据库的访问。
Android学习第六周_SQLite和ContentProvider
潼城旧事的博客
04-10 425
一、SQLite1、基本概念 SQLite是一个轻量级、独立、隔离、跨平台、多语言接口、安全性高的关系型数据库，主要用于嵌入式设备之上，Android中的数据库就是使用的是SQLite数据库。 2、创建数据库 1）创建类public class DataBaseHelper extends SQLiteOpenHelper2）编写DataBaseHelper的构造方法public DataBa
Android中数据存储的几种方式
weixin_48993339的博客
05-31 2792
5种分别为：文件存储、SQLite数据库、SharedPreferences、ContentProvider、网络。特点如下： 1）文件存储 Android中读取/写入文件的方法，与Java的I/O一样，提供openFileInput()和openFileOutput()方法来读取设备上的文件。 2）SQLite数据库 Android集成的一个轻量级的嵌入式数据库，支持Andorid API操作，也支持SQL语句进行增删改查等操作。 3）SharedPreferences Android提供的用于存储一些简
Android四大组件之一ContentProvider自定义Sqlite共享，实现增删查改基本功能
04-25
Android四大组件之一ContentProvider自定义Sqlite共享，实现增删查改基本功能
Android应用源码之Android导入导出txt通讯录工具-IT计算机-毕业设计.zip
04-06
通过这个项目，你可以学到Android应用的基本架构，数据存储方式，用户交互设计，以及多线程和文件操作等核心技能。同时，这也是一个很好的机会去实践软件工程中的最佳实践，如代码组织、注释和版本控制。
Android入门_-_数据库支持(SQLite),_内容提供器(ContentProvider).doc
10-19
Android开发平台为开发者提供了丰富的API来操作SQLite数据库，这些API主要集中在`android.database.sqlite`包中。通过这些API，开发者可以轻松地创建、更新、查询和删除数据库表中的数据。 **1.3 创建SQLite数据库*...
Android sql练习合集-IT计算机-毕业设计.zip
04-01
接下来，你会看到如何在Android中操作SQLite数据库。例如，使用SQL语句（如INSERT INTO、UPDATE、DELETE、SELECT）来管理数据。此外，SQLiteOpenHelper的getWritableDatabase()和getReadableDatabase()方法用于获取...
Android SQLite数据库操作详解
开发者可以直接在Android应用中操作SQLite数据库，实现数据的持久化存储。 SQLite在Android中的应用 - SQLiteOpenHelper: 这是Android提供的一个辅助类，用于创建、升级和打开数据库。通过重写`onCreate()`方法创建...
Android应用开发使用ContentProvider以及SQLite实现对数据库的相关操作
01-09
Android应用开发使用ContentProvider以及SQLite实现对数据库的相关操作，可以直接操作数据库，也可以使用ContentProvider来对数据库进行间接操作。
Android开发8：数据存储（二）——SQLite数据库和ContentProvider的使用
weixin_30952103的博客
02-23 949
前言 　　啦啦啦各位小伙伴们许久不见了~学期末和过年期间自己忙着做其他事没能及时更新Android开发系列课程的博客，实在是罪过罪过~ 好啦~废话不多说，进入我们今天的主题。今天我们将和大家学习其他的数据存储的方法，一起来学习SQLite数据库和ContentProvider的使用，复习Android界面编程等知识。 基础知识 　　SQLite 一. SQLite的介绍 1.SQLit...
Android之ContentProvider整合SQLite数据库实例
FeiPeng_的博客
10-22 1151
Android之ContentProvider整合SQLite数据库示例 转载请标明出处： 本文出自:【班飞鹏的博客】 目录 Android之ContentProvider整合SQLite数据库示例 目录 一概述 二2个重要的类Uri和UriMatcher类使用介绍 三图片演示示例 源码下载 一、概述 对于初学者而言对ContentProvider的理解总是糊里糊涂的，而且项目也不是经
Android 总结：ContentProvider 的使用
weixin_30627381的博客
10-16 111
一、概述 ContentProvider：为存储和获取数据提供统一的接口，可以在不同的应用程序之间共享数据。Android内置的许多数据都是使用ContentProvider形式，供开发者调用的 (如视频，音频，图片，通讯录等)。1. 使用表的形式来组织数据- 无论数据来源是什么，ContentProvider都会认为是一种表。（把数据组织成表格）2. 提供的方法- query：查询...
Android ContentProvider初探
qq_26779635的博客
03-26 2249
这几篇将围绕ContentProvider进行安全漏洞分析。 关于ContentProvider，网上有不少资料，但都零零碎碎，而且样例时间也较老，因此我整合了网上可靠资源，并结合自己实践给出一篇可靠的博客。 这篇将详细介绍ContentProvider的实现原理以及实例。 1. 概述 ContentProvideer用于提供数据的统一访问格式，封装底层的具体实现。对于数据使用者来说，无需...
弃掉Android 4.4获取系统图片出错之坑，实现 自定义相册库
热门推荐
寒雪无痕
07-08 11万+
弃掉Android 4.4获取系统图片出错之坑，抛掉Android自带的系统相册，实现Android自定义相册库
Android复习练习十二(自定义ContentProvider实现其他应用操作本应用SQLite数据库)
苦咖啡的自留地
09-06 2087
需求：自定义一个简单的ContentPro
Android中ContentProvider(内容题供着)2访问自定义的内容提供者，共享Sqlite数据库数据
翟浩浩Android专栏
01-07 765
ContentProvider（内容提供者）主要用于跨项目访问（操作）数据。 这个例子是自定义ContentProvider，共享Sqlite数据库数据，另一个程序访问ContentProvider 项目结构: Android_11_002_pd_data项目是创建数据库，并且用内容题供者提供数据。 包含3个类 MainActivity没用 DbOp
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值