阅读 2093

Android点将台:你敢摸我猫 [- IPC -]

零、前言:本文源码:GitHub

1.先在视觉上瞄一下进程和线程的区别


2.再从感性上类比一下进程和线程
如果手机是地球,进程就像一家公司,公司使用着地球的资源,也在地球上扮演一个独立的个体,实现自己特有的功能与价值。
而线程就像公司里的人,可以共享公司的公共资源,处理属于自己的任务,实现自身的功能与价值。
可以说进程(公司)是给线程(人)一个运行(工作)的环境。于此同时进程也获得了它的地位。

所以一个进程至少要一个线程来完成任务。进程销毁后,里面的线程也就失业拜拜了。
比如某公司的人(线程)集体罢工(崩溃),那公司无论曾经叫什么,都没有意义。公司(进程)倒闭了,再多的线程(人)也没卵用。

多进程就像若干个公司联盟做一个项目,这时候各个公司的内部资源(静态成员、单例等)就不再适用,
就像别的公司人到你公司吃你的零食,敲你键盘,摸你猫,你给吗? 不给,坚决不给。
然后那人非要吃你零食,敲你键盘,摸你猫,还搞出个职位叫IPC,说什么跨进程间通信。TM说白了就是专门抢你零食,抢你猫,你说气不气人。
复制代码

3.最后走一波概念
IPC(Inter-Process Communication): 进程间通信或者跨进程通信
进程:指的一个执行单元,在PC和移动设备上指的是一个程序或者一个应用。
线程:在操作系统中,线程是CPU调度的最小单元,也是一种有限的系统资源。
进程与线程关系:一个进程可以包含多个线程,因此进程和线程是包含被包含的关系。
复制代码

二、如何在一个应用创建多个进程

1.三个测试Activity

三个按钮跳转三个Activity,布局就不贴了。只贴一个MainActivity0,其他两个MainActivity1,MainActivity2

class MainActivity0 : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        title="MainActivity0"
        to_one.setOnClickListener {
            startActivity(Intent(this, MainActivity0::class.java))
        }
        to_two.setOnClickListener {
            startActivity(Intent(this, MainActivity1::class.java))
        }
        to_three.setOnClickListener {
            startActivity(Intent(this, MainActivity2::class.java))
        }
    }
}
复制代码

2.AndroidManifest.xml配置文件

私有进程:有:---------- 全局进程:没有: 名字可以随便取,只要唯一

<activity android:name=".MainActivity1"
          android:process=":ipc">
</activity>
<activity android:name=".MainActivity2"
          android:process="com.toly1994.ipc.test">
</activity>
复制代码

三、多进程与单进程的区别

1.打开Activity1时

不加的话,直接通过窗口管理器来显示Activity1


加的话,会在孵化一个进程。zygote64的日志很多,下面只是一小部分。
不清楚Activity启动和View加载过程的小伙伴,可以看一下这个日志,也许会有帮助
比如下面完美呈现了LayoutInflater是怎么运行的,再跟着源码走一走,你会有所收获


然后发现确实是多了两个,名字也能对应上


2.Application的多次实例化

既然开一个进程会孵化一次,ActivityThread的main方法被触发,Application自然会被新建
喵了个咪的,创建了三个,一个进程一个。这显然值得注意,自定义Application初始化第三方库什么的

public class CatApplication extends Application {
    private static final String TAG = "CatApplication";

    @Override
    public void onCreate() {
        super.onCreate();
        Log.e(TAG, "onCreate: 创建了小猫土土");
    }
}
复制代码

3.静态成员变量无法在不同进程获取
public class CatManager {
    public static Cat cat = new Cat();

    public CatManager() {
        cat = new Cat();
        cat.color = "灰色" + Math.random();
        cat.name = "土土";
    }
}

---->[MainActivity0#oncreate]------------------
CatManager()

---->[MainActivity1#oncreate]------------------
Log.e("CatManager", ": "+CatManager.cat.color);//null 

|--- 说明在MainActivity1里已经初始化的静态成员变量无法在MainActivity2(另一个进程)使用
|--- 如果将MainActivity2的process去掉可以打印:灰色0.22701789806635642
|--- 这就尴尬了,我的唯一玩到666的单例肿么办?
复制代码

4.单例模式会怎么样?

新建一个Cat(猫)和CatManager(铲屎官)的类

---->[Cat]------------------------------------
public class Cat {
    public String name;
    public String color;

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

---->[CatManager]------------------------------------
public class CatManager {
    private volatile static CatManager sCatManager;
    private static Cat cat=new Cat();

    private CatManager() {
    }

    public static CatManager newInstance() {
        if (sCatManager == null) {
            synchronized (CatManager.class) {
                if (sCatManager == null) {
                    sCatManager = new CatManager();
                    Log.e("CatApplication", "newInstance: ");

                    cat.color = "灰色"+Math.random();
                    cat.name = "土土";
                }
            }
        }
        return sCatManager;
    }

    public Cat getCat() {
        return cat;
    }
}

---->[CatApplication]------------------------------------
public class CatApplication extends Application {
    private static final String TAG = "CatApplication";

    @Override
    public void onCreate() {
        super.onCreate();
        CatManager manager = CatManager.newInstance();
        Log.e("CatApplication", manager.getCat().toString());
    }
}
复制代码
2019-05-08 10:18:02.482 25524-25524/? E/CatApplication: newInstance: 
2019-05-08 10:18:02.482 25524-25524/? E/CatApplication: Cat{name='土土', color='灰色0.8695394451026908'}
2019-05-08 10:18:04.761 25561-25561/com.toly1994.ipc:ipc E/CatApplication: newInstance: 
2019-05-08 10:18:04.761 25561-25561/com.toly1994.ipc:ipc E/CatApplication: Cat{name='土土', color='灰色0.9824119267379914'}
2019-05-08 10:18:07.096 25597-25597/com.toly1994.ipc.test E/CatApplication: newInstance: 
2019-05-08 10:18:07.096 25597-25597/com.toly1994.ipc.test E/CatApplication: Cat{name='土土', color='灰色0.18620946012650275'}
复制代码

可见单例也没有卵用了,每次开启进程都会执行到newInstance,导致单例的失调。


5.小结:多进程带来的问题(老生常谈)
Application会多次创建:开启一个进程其实就等同于开多一个Application
静态成员和单例模式完全失效(处于不同的内存块(进程),拥有各自的副本) 
SharedPreferences的可靠性降低:因为SharedPreferences不支持两个进程同时去读写xml文件 
线程同步机制完全失效(同一差不多) 
复制代码

三、IPC的几种形式

为了多公司联盟(多进程)间的和谐,现在决定牺牲猫,让它可以被过各公司(进程)共享

[1].通过Intent传递Bundle对象通信: 简单,数据类型局限,用于组件间传递数据
[2].使用共享文件通信: 简单,实时性差,不适合高并发
[3].使用Messenger通信: 支持一对多串行通信,支持实时通信,不支持RPC
[4].使用AIDL通信: 支持一对多并发通信,适用于,一对多通信且有RPC需求
[5].使用ContentProvider: 支持一对多并发数据共享
[6].使用Socket: 可以通过网络传输字节流,支持一对多并发实时通信
复制代码

0.现在的CatManager类和Cat类

既然单例不能用,就不用。这里默认开局一只猫。Cat实现序列化接口Serializable

public class CatManager {
    private static List<Cat> cats = new ArrayList<>();
    public CatManager() {
        Cat tutu = new Cat();
        tutu.color = "灰色" + Math.random();
        tutu.name = "土土";
        add(tutu);
    }
    public void add(Cat cat) {
        cats.add(cat);
    }
    public Cat getCatAt(int index) {
        return cats.get(index);
    }
}

public class Cat implements Serializable {
    public String name;
    public String color;

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}
复制代码

1.IPC之Intent发送Bundle对象通信
1-1.Serializable序列化对象实现
---->[MainActivity0#oncreate]------------------
to_two.setOnClickListener {
    val cat = CatManager().getCatAt(0)
    val bundle = Bundle()//创建Bundle对象
    bundle.putSerializable("cat", cat)//把猫装到Bundle里,贴个标签cat
    val intent = Intent(this, MainActivity1::class.java)
    intent.putExtras(bundle)
    startActivity(intent)
}

---->[MainActivity1#oncreate]------------------
val cat = intent.extras?.get("cat") as Cat //把Bundle用打开标签cat,然后猫到手
Log.e("MainActivity1", ": " + cat.name)//MainActivity1可以对猫为所欲为,IPC 通信完成
复制代码

注:当然你也可以直接通过Intent发送序列化(Serializable)对象,源码瞄一眼,都是通过Bundle的,并无本质区别

public @NonNull Intent putExtra(String name, Serializable value) {
    if (mExtras == null) {
        mExtras = new Bundle();
    }
    mExtras.putSerializable(name, value);
    return this;
}
复制代码

1-2.Parcelable序列化对象实现

Android里说Serializable,怎么能少得了同胞兄弟Parcelable呢,两者都是对象序列化的手段
两者的详细比较这里就不赘述,详见:Android点将台的Intent篇。什么是序列化和反序列化,个人理解如下:

比如我家有个大的衣柜(对象),现在要搬家,一下子搬不走,怎么办?
把每块板贴个标签,然后拆了,一块块摆好,然后就能运走了,这叫序列化。
然后到新家里,把板再一块块地拼起来,然后大衣柜(对象)就又回来了,这叫反序列化。

上面说的是物质对象的运输过程,那么信息/数据对象也可以这么类比,思想上是[怎么好运和拼装还原]
Serializable和Parcelable不影响序列化的概念,只是手段不同,就像是卡车运还是飞机运一样
Serializable和Parcelable接口代表这东西可拆,是一种可拆保证。要什么都乱拆,你家猫拆个试试。
下面直播拆猫:AS自动生成Parcelable相关代码,可以省我们一些事,but,请千万要了解一下他们是干嘛用的
复制代码

---->[MainActivity0#oncreate]------------------
to_two.setOnClickListener {
    val cat = CatManager().getCatAt(0)
    val bundle = Bundle()//创建Bundle对象
    bundle.putParcelable("cat", cat)//把猫装到Bundle里,贴个标签cat
    val intent = Intent(this, MainActivity1::class.java)
    intent.putExtras(bundle)
    startActivity(intent)
}

---->[MainActivity1#oncreate]------------------
val cat = intent.extras?.get("cat") as Cat //把Bundle用打开标签cat,然后猫到手
Log.e("MainActivity1", ": " + cat.name)//MainActivity1可以对猫为所欲为,IPC 通信完成
复制代码

2.IPC之文件共享进行通信

把对象写入文件,然后通过文件反序列化出对象,给MainActivity2
(文件读写无论是效率还是多线程的不行,所以这里只是了解一下)

---->[MainActivity0#oncreate]------------------
to_three.setOnClickListener {
    val cat = CatManager().getCatAt(0)
    val file = File(cacheDir, "cat.obj")
    val oos = ObjectOutputStream(FileOutputStream(file))
    oos.writeObject(cat)
    oos.close()
    startActivity(Intent(this, MainActivity2::class.java))
}

---->[MainActivity2#oncreate]------------------
val file = File(cacheDir, "cat.obj")
val ois = ObjectInputStream(FileInputStream(file))
val cat = ois.readObject() as Cat//反序列化生成对象
ois.close()
Log.e("MainActivity1", ": " + cat.name)//MainActivity1可以对猫为所欲为,IPC 通信完成
复制代码

可能到这你觉得IPC不就是传个对象吗?好像没什么大不了的


3.IPC之Messenger通信
3-1:Messenger是什么?

从都构造函数来看,是和Binder有关

private final IMessenger mTarget;

public Messenger(Handler target) {
    mTarget = target.getIMessenger();
}

public Messenger(IBinder target) {
    mTarget = IMessenger.Stub.asInterface(target);
}
复制代码

3-2:可以获取一个Ibinder对象

如此看来mTarget即IMessenger类很像一个AIDL接口

public IBinder getBinder() {
    return mTarget.asBinder();
}
复制代码

3-3:Messenger的使用

既然是Ibinder对象,可以用在绑定服务中。既然个公司(摸)的人都要猫,干脆来个服务端。
谁(客户端)想来摸一下都可以,核心是Messenger发送消息,Service里接收消息

---->[CatService]------------------
public class CatService extends Service {
    @Override
    public IBinder onBind(Intent intent) {
        return new Messenger(new Handler(msg -> {
            //接收客户端数据/信息/对象
            String data = msg.getData().getString("request");
            Log.e("MessengerActivity", "handleMessage: " + data);
            
            //向客户端发送数据/信息/对象
            Messenger client = msg.replyTo;
            Message message = Message.obtain();
            Cat cat = new CatManager().getCatAt(0);
            Bundle bundle = new Bundle();//创建Bundle对象
            bundle.putParcelable("cat", cat);//把猫装到Bundle里,贴个标签cat
            message.setData(bundle);
            try {
                client.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            return false;
        })).getBinder();
    }
}

---->[将服务单独放在一个进程]--------------
<service android:name=".CatService"
         android:process="com.toly1994.ipc.service.cat"/>

---->[MessengerActivity]------------------
public class MessengerActivity extends AppCompatActivity {
    private static final String TAG = "MessengerActivity";
    private ServiceConnection conn;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        conn = new ServiceConnection() {
            private Messenger messenger;
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                messenger = new Messenger(service);
                Message message = Message.obtain();
                Bundle bundle = new Bundle();
                bundle.putString("request", "来自客户端:给我一只猫");
                message.setData(bundle);
                message.replyTo = new Messenger(new Handler((msg) -> {//服务端回应监听
                    Bundle data = msg.getData();
                    data.setClassLoader(getClass().getClassLoader());
                    Cat cat = (Cat) (data.get("cat"));
                    Log.e(TAG, "来自服务端: "+cat);
                    return false;
                }));
                try {
                    messenger.send(message);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
            @Override
            public void onServiceDisconnected(ComponentName name) {
            }
        };
        bindService(new Intent(this, CatService.class), conn, Context.BIND_AUTO_CREATE);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn);
    }
}
复制代码

注意这里有一个坑,一开始读不出来异常如下,看名字感觉是类加载器的锅,貌似找不到Cat类
解决: data.setClassLoader(getClass().getClassLoader());

流程基本如下,并不知道两个Handler和三个Messenger,还有皮球一样乱跑的Message有没有把你绕晕


4.IPC之AIDL通信

这个不怎么想说,在Android点将台:金科玉律[-AIDL-]里已经讲得很详细了,为了完整一点,这里稍微再说一下吧。

4-1:定义接口:ICatService

简单一点,就定义一个喂养的方法


4-2:自动生成的类

类之间的关系基本如下:

package com.toly1994.ipc;
public interface ICatService extends android.os.IInterface {
    public static abstract class Stub extends android.os.Binder implements com.toly1994.ipc.ICatService {
        private static final java.lang.String DESCRIPTOR = "com.toly1994.ipc.ICatService";
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }
        //通过IBinder获取ICatService对象,绑定客户端时使用
        public static com.toly1994.ipc.ICatService asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.toly1994.ipc.ICatService))) {
                return ((com.toly1994.ipc.ICatService) iin);
            }
            return new com.toly1994.ipc.ICatService.Stub.Proxy(obj);
        }

        @Override
        public android.os.IBinder asBinder() {
            return this;
        }

        @Override//此方法运行在服务端Binder线程池中,客户端发起跨进程请求时,远程请求通过系统底层封装后交由此方法处理
        public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
            java.lang.String descriptor = DESCRIPTOR;
            switch (code) {
                case INTERFACE_TRANSACTION: {
                    reply.writeString(descriptor);
                    return true;
                }
                case TRANSACTION_feed: {
                    data.enforceInterface(descriptor);
                    java.lang.String _arg0;
                    _arg0 = data.readString();
                    this.feed(_arg0);
                    reply.writeNoException();
                    return true;
                }
                default: {
                    return super.onTransact(code, data, reply, flags);
                }
            }
        }
        //代理类,当客户端访问服务端时,客户端通过代理类生成一个ICatService对象 
        private static class Proxy implements com.toly1994.ipc.ICatService {
            private android.os.IBinder mRemote;

            Proxy(android.os.IBinder remote) {
                mRemote = remote;
            }

            @Override
            public android.os.IBinder asBinder() {
                return mRemote;
            }

            public java.lang.String getInterfaceDescriptor() {
                return DESCRIPTOR;
            }

            @Override
            public void feed(java.lang.String aString) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    _data.writeString(aString);
                    mRemote.transact(Stub.TRANSACTION_feed, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }

        static final int TRANSACTION_feed = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    }

    public void feed(java.lang.String aString) throws android.os.RemoteException;
}

复制代码

4-3:使用ICatService创建FeedCatService

优势在于客户端绑定服务是通过:ICatService.Stub.asInterface(service)获取ICatService对象
就可以调用ICatService接口方法。这样只暴露接口,可以限制客户端对小猫的操作,客户端即玩了,又不能为所欲为。

---->[FeedCatService]--------------------------------------
public class FeedCatService extends Service {
    private static final String TAG = "FeedCatService";
    private Binder binder = new ICatService.Stub() {
        @Override
        public void feed(String aString) throws RemoteException {
            Log.e(TAG, "feed: 你已喂" + aString + "给小猫土土了");
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }
}

---->[将服务单独放在一个进程]---------------------------------
<service android:name=".FeedCatService"
         android:process="com.toly1994.ipc.service.feed.cat"/>
         
---->[AidlActivity]---------------------------------
public class AidlActivity extends AppCompatActivity {
    private ServiceConnection conn;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        conn = new ServiceConnection() {
            private ICatService catService;
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                catService = ICatService.Stub.asInterface(service);
                try {
                    catService.feed("鱼");
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
            @Override
            public void onServiceDisconnected(ComponentName name) {
            }
        };
        bindService(new Intent(this, FeedCatService.class), conn, Context.BIND_AUTO_CREATE);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn);
    }
}
复制代码

5.IPC之使用ContentProvider通信
5.1:数据库辅助
    private static String DATABASE_NAME = "cat.db";//数据库名
    private static int DATABASE_VERSION = 1;//数据库版本
    private volatile static CatDatabaseHelper sInstance;
    //双检锁单例
    public static synchronized CatDatabaseHelper getInstance(Context context) {
        if (sInstance == null) {
            synchronized (CatDatabaseHelper.class) {
                if (sInstance == null) {
                    sInstance = new CatDatabaseHelper(context);
                }
            }
        }
        return sInstance;
    }
    public CatDatabaseHelper(@Nullable Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
    @Override
    public void onCreate(SQLiteDatabase db) {
        createSwordTable(db);
    }
    /**
     * 创建sword表
     *
     * @param db SQLiteDatabase
     */
    private void createSwordTable(SQLiteDatabase db) {
        db.execSQL("CREATE TABLE cat (" +
                "id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," +
                "name VARCHAR(32) NOT NULL," +
                "color VARCHAR(32) NOT NULL" +
                "); ");
    }
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    }
}
复制代码

5.2:继承ContentProvider
public class CatContentProvider extends ContentProvider {
    private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
    private static final int CAT_QUERY = 0;
    private static final int CAT_INSERT = 1;
    private static final int CAT_UPDATE = 2;
    private static final int CAT_DELETE = 3;
    private static final String TABLE_NAME = "cat";
    static {
        //给当前sUriMatcher添加匹配规则
        sUriMatcher.addURI("toly1994.com.cat", "query", CAT_QUERY);
        sUriMatcher.addURI("toly1994.com.cat", "insert", CAT_INSERT);
        sUriMatcher.addURI("toly1994.com.cat", "update", CAT_UPDATE);
        sUriMatcher.addURI("toly1994.com.cat", "delete", CAT_DELETE);
    }
    private SQLiteOpenHelper mOpenHelper;
    @Override
    public boolean onCreate() {
        mOpenHelper = CatDatabaseHelper.getInstance(getContext());
        return true;
    }
    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        //进行uri匹配
        int result = sUriMatcher.match(uri);
        if (result == CAT_QUERY) {
            SQLiteDatabase db = mOpenHelper.getReadableDatabase();
            return db.query(TABLE_NAME, projection, selection, selectionArgs, null, null, sortOrder);
        } else {
            throw new IllegalStateException(" query Uri 错误");
        }
    }
    @Override
    public String getType(Uri uri) {
        return null;
    }
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        //进行uri匹配
        int result = sUriMatcher.match(uri);
        if (result == CAT_INSERT) {
            SQLiteDatabase db = mOpenHelper.getWritableDatabase();
            Long insert = db.insert(TABLE_NAME, null, values);
            //uri:数据发送变化,通过uri判断调用哪个内容观察者
            //第二个参数:内容观察者对象  如果传null 则注册了整个uri的内容观察者皆可以收到通知
            getContext().getContentResolver().notifyChange(uri, null);
            db.close();
            return Uri.parse(String.valueOf(insert));
        } else {
            throw new IllegalStateException("insert Uri 错误");
        }
    }
    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        //进行uri匹配
        int result = sUriMatcher.match(uri);
        if (result == CAT_DELETE) {
            SQLiteDatabase db = mOpenHelper.getWritableDatabase();
            int delete = db.delete(TABLE_NAME, selection, selectionArgs);
            db.close();
            return delete;
        } else {
            throw new IllegalStateException("delete Uri  错误");
        }
    }
    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        //进行uri匹配
        int result = sUriMatcher.match(uri);
        if (result == CAT_UPDATE) {
            SQLiteDatabase db = mOpenHelper.getWritableDatabase();
            int update = db.update(TABLE_NAME, values, selection, selectionArgs);
            db.close();
            return update;
        } else {
            throw new IllegalStateException("update Uri 错误");
        }
    }
}

---->[配置]---------------------------------------------
<provider android:authorities="toly1994.com.cat"
          android:name=".CatContentProvider"
          android:exported="true"
          android:process="com.toly1994.ipc.provider.cat"
/>
复制代码

5.3:使用

这样不同的进程就可以通过getContentResolver来操作数据库了

public class ProviderActivity extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        insert(getContentResolver());
    }
    /**
     * 插入测试
     *
     * @param resolver
     */
    private void insert(ContentResolver resolver) {
        Uri uri = Uri.parse("content://toly1994.com.cat/insert");
        ContentValues values = new ContentValues();
        values.put("name", "土土");
        values.put("color", "灰色");
        resolver.insert(uri, values);
    }
}
复制代码


6.使用Socket

Socket可以让两个设备间的通信,两个进程自然也不在话下
这里不深入,只是客户端发一句话,服务端接收一下

---->[SocketService]---------------------------------
public class SocketService extends Service {
    private static final String TAG = "SocketService";
    private boolean quit = false;
    
    @Override
    public void onCreate() {
        Log.e(TAG, "onCreate: ");
        FeedServer feedServer = new FeedServer();
        new Thread(feedServer).start();
        super.onCreate();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    private class FeedServer implements Runnable {

        @Override
        public void run() {
            ServerSocket serverSocket = null;
            try {
                serverSocket = new ServerSocket(8080);
                Log.e(TAG, "serverSocket onCreate: ");
            } catch (IOException e) {
                e.printStackTrace();
            }

            while (!quit) {
                try {
                    Socket socket = serverSocket.accept();
                    //接收客户端消息
                    BufferedReader br = new BufferedReader(
                            new InputStreamReader(socket.getInputStream()));
                    String s = br.readLine();
                    Log.e(TAG, "来自客户端: " + socket.getInetAddress() + "说:" + s);

                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

---->[将服务单独放在一个进程]---------------------------------
<service android:name=".SocketService"
         android:process="com.toly1994.ipc.service.socket.feed.cat"/>
         
---->[ServerActivity]---------------------------------
public class ServerActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        startService(new Intent(this, SocketService.class));
        findViewById(R.id.to_one).setOnClickListener(v -> {
            new Thread(() -> {
                Socket socket = null;
                try {
                    socket = new Socket("localhost", 8080);
                    //客户端请求
                    BufferedWriter bw = new BufferedWriter(
                            new OutputStreamWriter(socket.getOutputStream()));
                    bw.write("我要猫");
                    bw.flush();
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();

        });

    }
}
复制代码

OK,本文就先这样,《Android开发艺术探索》是本不错的书,有多瞄几眼的价值。

关注下面的标签,发现更多相似文章
评论