上篇博客主要介绍了sharedUserId&&Messenger作为IPC通信的用法,接着这篇博客要介绍到的是ContentProvider和Socket的详细使用方法。
android IPC通信(上)-sharedUserId&&Messenger
android IPC通信(下)-AIDL
ContentProvider
ContentProvider是android中提供的专门用于不同应用间数据共享的方式,从这一点来看,它天生就适合进程间通信。和Messenger一样,ContentProvider的底层实现同样是Binder,由此可见,Binder在android系统中是何等的重要。ContentProvider也对Binder进行了封装,使用起来很方便。
实现自己的ContentProvider需要实现相关的6个方法,onCreate,query,update,insert,delete和getType。虽然ContentProvider的底层数据看起来很像一个SQLite数据库,但是ContentProvider对底层的数据存储方式没有任何要求,我们既可以使用SQLite数据库,也可以使用普通的文件,甚至可以采用内存中的一个对象来进行数据的存储,详细的ContentProvider可以去查阅相关资料,这里就着重介绍一下跨进程的使用。
先看看manifest文件中,该provider的相关注册信息:
<manifest package="com.android.contentprovider"
xmlns:android="http://schemas.android.com/apk/res/android">
<permission android:name="com.android.CONTENTPROVIDER_READPERMISSSION"
android:permissionGroup="android.permission-group.STORAGE"
android:protectionLevel="signature"/>
<uses-permission android:name="com.android.CONTENTPROVIDER_READPERMISSSION"/>
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
<provider
android:authorities="com.android.StudentProvider"
android:name="com.android.contentprovider.StudentProvider"
android:permission="com.android.CONTENTPROVIDER_READPERMISSSION"
android:process=":provider"/>
</application>
</manifest>
我们将ContentProvider置于另一个进程中,这样就实现了进程之间的通信,当然也可以将ContentProvider置于另一个应用中,用法是非常类似的。android:authorities是ContentProvider的唯一标识,通过这个属性外部应用就可以访问我们的provider,如果需要多个授权,用分号隔开即可,还有一个是必须要保持android:authorities的唯一性。android:permission标签用来限制访问该provider时必须要声明的权限,当然也可以细分为android:writePermission和android:readPermission。在manifest中使用permission标签声明一个权限,并且使用uses-permission使用该权限,这方面的详细介绍可以看http://blog.csdn.net/self_study/article/details/50074781这篇博客,在这就不介绍了。
再来看该ContentProvider的具体实现代码:
public class StudentProvider extends ContentProvider {
public static final String AUTHORITY = "com.android.StudentProvider";
public static final Uri STUDENT_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/student");
public static final Uri GRADE_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/grade");
public static final int STUDENT_URI_CODE = 0;
public static final int GRADE_URI_CODE = 1;
private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
static {
sUriMatcher.addURI(AUTHORITY, "student", STUDENT_URI_CODE);
sUriMatcher.addURI(AUTHORITY, "grade", GRADE_URI_CODE);
}
private SQLiteDatabase mDb;
@Override
public boolean onCreate() {
mDb = new DbOpenHelper(getContext()).getWritableDatabase();
return true;
}
@Override
public Cursor query(Uri uri, String[] columns, String selection,
String[] selectionArgs, String sortOrder) {
String table = getTableName(uri);
if (table == null) {
throw new IllegalArgumentException("Unsupported URI: " + uri);
}
return mDb.query(table, columns, selection, selectionArgs, null, null, sortOrder, null);
}
@Override
public String getType(Uri uri) {
return null;
}
@Override
public Uri insert(Uri uri, ContentValues values) {
String table = getTableName(uri);
if (table == null) {
throw new IllegalArgumentException("Unsupported URI: " + uri);
}
mDb.insert(table, null, values);
getContext().getContentResolver().notifyChange(uri, null);
return uri;
}
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
String table = getTableName(uri);
if (table == null) {
throw new IllegalArgumentException("Unsupported URI: " + uri);
}
int count = mDb.delete(table, selection, selectionArgs);
if (count > 0) {
getContext().getContentResolver().notifyChange(uri, null);
}
return count;
}
@Override
public int update(Uri uri, ContentValues values, String selection,
String[] selectionArgs) {
String table = getTableName(uri);
if (table == null) {
throw new IllegalArgumentException("Unsupported URI: " + uri);
}
int row = mDb.update(table, values, selection, selectionArgs);
if (row > 0) {
getContext().getContentResolver().notifyChange(uri, null);
}
return row;
}
private String getTableName(Uri uri) {
String tableName = null;
switch (sUriMatcher.match(uri)) {
case STUDENT_URI_CODE:
tableName = DbOpenHelper.STUDENT_TABLE_NAME;
break;
case GRADE_URI_CODE:
tableName = DbOpenHelper.GRADE_TABLE_NAME;
break;
default:break;
}
return tableName;
}
public class DbOpenHelper extends SQLiteOpenHelper {
private static final String DB_NAME = "student_provider.db";
public static final String STUDENT_TABLE_NAME = "student";
public static final String GRADE_TABLE_NAME = "grade";
public DbOpenHelper(Context context) {
super(context, DB_NAME, null, 1);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.beginTransaction();
String sql;
sql = "create table if not exists "+ STUDENT_TABLE_NAME + " (";
sql += "id integer not null primary key , ";
sql += "name varchar(40) not null default 'unknown', ";
sql += "gender varchar(10) not null default 'male',";
sql += "weight float not null default '60'";
sql += ")";
db.execSQL(sql);
sql = "create table if not exists "+GRADE_TABLE_NAME+ " (";
sql += "id integer not null primary key autoincrement, ";
sql += "chinese float not null default '0', ";
sql += "math float not null default '0', ";
sql += "english float not null default '0'";
sql += ")";
db.execSQL(sql);
db.setTransactionSuccessful();
db.endTransaction();
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
}
}
我们使用SQLite实现该ContentProvider的数据存储,关于数据库的相关使用方法可以查阅资料(关于数据库封装,我写了一个,大家可以多提提意见https://github.com/zhaozepeng/Android_framework/tree/master/libcore/src/main/java/com/android/libcore/database)。在该student_provider.db中建了student和grade两个表用来存储相关信息。
ContentProvider使用uri来区别外界要访问的数据集合,为了知道外界要访问的是哪个表,我们需要为他们定义单独的uri和uri code,并且使用UriMathcer类将uri和uri code关联,这样根据外界的uri就能够知道它想要访问哪张表了。
query,update,insert和delete方法的具体实现很相似也很简单,具体看代码就明白了,唯一一点不同就是后面三个方法会引起数据源的改变,这时候我们需要通过ContentResolver的notifyChange方法来通知外界当前ContentProvider中的数据已经发生改变。还有一点需要说明的是这四个方法是存在多线程并发访问的,因此方法内部要做好线程同步。上面代码由于只有一个SQLiteDatabase对象,所以能够正确应对多线程问题,但是如果通过多个SQLiteDatabase对象访问该数据库,就会出现线程同步问题,这点需要注意。
接下来就是要通过外部访问该ContentProvider了:
public class MainActivity extends BaseActivity implements View.OnClickListener{
Uri studentUri;
Uri gradeUri;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.layout_mainactivity);
findViewById(R.id.btn_query).setOnClickListener(this);
studentUri = StudentProvider.STUDENT_CONTENT_URI;
gradeUri = StudentProvider.GRADE_CONTENT_URI;
ContentValues studentValues = new ContentValues();
studentValues.put("id", 1);
studentValues.put("name", "zhao");
studentValues.put("gender", "male");
studentValues.put("weight", 68.5);
getContentResolver().insert(studentUri, studentValues);
ContentValues gradeValues = new ContentValues();
gradeValues.put("id", 1);
gradeValues.put("chinese", 90.5);
gradeValues.put("math", 80.5);
gradeValues.put("english", 91.5);
getContentResolver().insert(gradeUri, gradeValues);
}
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.btn_query:
StringBuilder stringBuilder = new StringBuilder();
Cursor cursor= getContentResolver().query(studentUri, null, null, null, null);
stringBuilder.append("STUDENT\n");
while (cursor.moveToNext()){
stringBuilder.append("id:").append(cursor.getString(0)).append("\n");
stringBuilder.append("name:").append(cursor.getString(1)).append("\n");
stringBuilder.append("gender:").append(cursor.getString(2)).append("\n");
stringBuilder.append("weight:").append(cursor.getString(3)).append("\n");
}
cursor.close();
cursor = getContentResolver().query(gradeUri, null, null, null, null);
stringBuilder.append("GRADE\n");
while (cursor.moveToNext()){
stringBuilder.append("id:").append(cursor.getString(0)).append("\n");
stringBuilder.append("chinese:").append(cursor.getString(1)).append("\n");
stringBuilder.append("math:").append(cursor.getString(2)).append("\n");
stringBuilder.append("english:").append(cursor.getString(3)).append("\n");
}
cursor.close();
((TextView)findViewById(R.id.tv_result)).setText(stringBuilder);
break;
}
}
}
插入查询操作都能成功,也就实现了ContentProvider的IPC通信了。
项目下载地址:https://github.com/zhaozepeng/IPC-demo/tree/master/ContentProvider
Socket
Socket称为“套接字”,是网络通信中的概念,他分为流式套接字和用户数据报套接字两种,分别对应于网络传输控制层中的TCP和UDP协议。TCP协议是面向连接的协议,提供稳定的双向通信功能;而UDP是无连接的,提供不稳定的单向通信功能。在性能上,UDP具有更好的效率,缺点是不能保证数据一定能够正确传输,尤其是在网络拥塞的情况下。具体TCP和UDP的区别可以查阅相关资料。
- 基于TCP的socket编程
- • java.net.ServerSocket是用来创建服务器端的套接字socket。
• java.net.Socket是用来创建客户端的套接字socket。 - 基于UDP的socket编程
- • java.net.DatagramSocket(数据电报套接字)。
• java.net.DatagramPacket(数据电报包,里面包含了发送的信息)。
<manifest package="com.android.socket"
xmlns:android="http://schemas.android.com/apk/res/android">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".SocketClient">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
<service android:name=".SocketServer"
android:process=":socket"/>
</application>
</manifest>
其次还需要注意的是在4.0之后,是不能够在主线程中执行网络访问的,要不然会抛出NetworkOnMainThreadException。接着先来看看服务器端的代码:
public class SocketServer extends Service{
private boolean mIsServiceDestroyed = false;
@Override
public void onCreate() {
new Thread(new TcpServer()).start();
super.onCreate();
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onDestroy() {
mIsServiceDestroyed = true;
super.onDestroy();
}
private class TcpServer implements Runnable {
@Override
public void run() {
ServerSocket serverSocket;
try {
//监听8688端口
serverSocket = new ServerSocket(8688);
} catch (IOException e) {
L.e(e);
return;
}
while (!mIsServiceDestroyed) {
try {
// 接受客户端请求,并且阻塞直到接收到消息
final Socket client = serverSocket.accept();
new Thread() {
@Override
public void run() {
try {
responseClient(client);
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private void responseClient(Socket client) throws IOException {
// 用于接收客户端消息
BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
// 用于向客户端发送消息
PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(client.getOutputStream())), true);
while (!mIsServiceDestroyed) {
String str = in.readLine();
if (str == null) {
break;
}
L.i("server has received '" + str +"'");
String message = "server has received your message";
out.println(message);
}
out.close();
in.close();
client.close();
}
}
一定要注意的是Service也是运行在主线程,所以不能直接在onCreate函数中去建立TCP连接,也需要另开一个线程去处理。这里我们使用8688端口去建立和客户端的连接,接着循环去接收该端口的消息数据,serverSocket.accept()函数会阻塞直到有消息的到来。接收到消息之后会返回一个客户端Socket对象,使用getInputStream()来读取该消息内容;使用getOutputStream()并且将其装饰成PrintWriter来向客户端发送消息。最后记得将相关对象close即可。
再来看看客户端代码:
public class SocketClient extends BaseActivity implements OnClickListener{
private Button mSendButton;
private EditText mMessageEditText;
private PrintWriter mPrintWriter;
private Socket mClientSocket;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_tcpclient);
mSendButton = (Button) findViewById(R.id.send);
mSendButton.setOnClickListener(this);
mMessageEditText = (EditText) findViewById(R.id.msg);
Intent service = new Intent(this, SocketServer.class);
startService(service);
new Thread() {
@Override
public void run() {
connectTCPServer();
}
}.start();
}
private void connectTCPServer() {
Socket socket = null;
while (socket == null) {
try {
//选择和服务器相同的端口8688
socket = new Socket("localhost", 8688);
mClientSocket = socket;
mPrintWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
} catch (IOException e) {
SystemClock.sleep(1000);
}
}
try {
// 接收服务器端的消息
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
while (!isFinishing()) {
String msg = br.readLine();
if (msg != null) {
String time = formatDateTime(System.currentTimeMillis());
L.i("client has received '" + msg + "' at " + time);
}
}
mPrintWriter.close();
br.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
protected void onDestroy() {
if (mClientSocket != null) {
try {
mClientSocket.shutdownInput();
mClientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
super.onDestroy();
}
@Override
public void onClick(View v) {
if (v == mSendButton) {
final String msg = mMessageEditText.getText().toString();
if (!TextUtils.isEmpty(msg) && mPrintWriter != null) {
//像服务器发送信息
L.i("client has send '" + msg + "' at " + formatDateTime(System.currentTimeMillis()));
mPrintWriter.println(msg);
mMessageEditText.setText("");
}
}
}
private String formatDateTime(long time) {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(time));
}
客户端用来发送消息至服务器,同样的TCP连接不能够放在onCreate主线程中执行,新建一个线程去建立TCP连接。该线程中每隔1000ms就会去连接服务端Socket直到连接成功,连接成功之后,同样使用getOutputStream函数,并且装饰成PrintWriter对象用来进行消息的发送,最后建立循环去读取8688端口的消息并且打印出来。看看最后的结果:
com.android.socket I/[PID:20730]: [TID:1] SocketClient.onClick(line:99): client has send 'hello i am client' at 2015-12-14 15:59:18
com.android.socket:socket I/[PID:20784]: [TID:5918] SocketServer.responseClient(line:90): server has received 'hello i am client'
com.android.socket I/[PID:20730]: [TID:5902] SocketClient.connectTCPServer(line:69): client has received 'server has received your message' at 2015-12-14 15:59:18
通过日志可以清楚地看到SocketServer是在20784进程中,SocketClient是在20730进程中,很明显的跨进程之间的通信。
当然Socket除了使用TCP套接字之外,还能够使用UDP套接字。另外通过Socket不仅仅能够实现进程之间的通信,还可以实现设备间的通信,前提是这些设备之间的IP地址互相可见,如果需要继续深入可以去查阅相关的资料,在这就不介绍了。
源码下载:https://github.com/zhaozepeng/IPC-demo/tree/master/Socket