Android内的IPC其他方法

android开启Sys V IPC,并使用共享内存编程 删除config中-# CONFIG_SYSVIPC is not set在rk3576.config中增加CONFIG_SYSVIPC=y去掉shm限制。 阅读详情

Bundle

实现了parcelable序列化的类,可以跨进成通信
例如在activity和service中跨进程通信

                Bundle bundle = new Bundle();
                bundle.putString("a","a");
                intent.putExtras(bundle);
//                bindService(intent, myserviceconnection, BIND_AUTO_CREATE);如果不需要调用binder获取服务就不用使用bindService方法
                startService(intent);

service端

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Bundle bundle = intent.getExtras();
        Log.e("xxxxx", "bundle传递的值:"+(String) bundle.get("a"));
        return super.onStartCommand(intent, flags, startId);
    }

文件共享

可以将数据、对象写入一个共享文件(外部存储位置即可)中,多个进程就可以同时读写这个文件,windows上如果文件加了排斥锁,就会导致外部线程不能读写,但是linux没有这种限制。但是同时多谢可能会产生一些问题,还是需要注意的。
尽量避免并发读写
还有另一种轻量级的文件SharedPreferences文件,当他设置为全局模式,也是一种共享文件

创建SharedPreferences文件

                SharedPreferences sharedPreferences = getSharedPreferences("a.xml",Context.MODE_WORLD_WRITEABLE);
                SharedPreferences.Editor editor = sharedPreferences.edit();
                editor.putString("a","a");
                editor.commit();

另外一个进程判断文件是否可读

        File file = new File("/data/data/com.app.typicallifecycle/shared_prefs/a.xml.xml");
        Log.e("xxxxx","is this file readable? "+ String.valueOf(file.canRead()));

结果返回:E/xxxxx: is this file readable? true

Messager(信使)

这个Messenger类是通过message来传递消息数据,可以从源码中看出。所以它是不能并发来进程通信的

    public void send(Message message) throws RemoteException {
        mTarget.send(message);
    }

并且它的底层也是通过AIDL实现的。看Messenger.java代码,从Stub.asInterface就已经很熟悉了对吧,然后我们再看看IMessenger这个android/platform/frameworks/base/android-9.0.0_r21/./core/java/android/os/IMessenger.aidl文件就可以完全确定了

....
    public Messenger(IBinder target) {
        mTarget = IMessenger.Stub.asInterface(target);
    }

在传递数据方面,有arg1,arg2,obj,Bundle,replyTo。obj可以传递由aidl生成的自定义的数据对象,Bundle也可以并且基础类型也比obj稍微多一些。下面是一个使用Bundle传递数据的实现

简单实例:跨进成发消息
客户端(这里的客户端、服务端就是两个进程):发起绑定请求,成功连接上就通过信使Messenger对象传递字符数据

 private ServiceConnection myserviceconnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //连接上服务的回调函数
            Log.e("xxxxx", name.getClassName());
            //从传过来的ibinder对象中获取一个信使messenger对象
            Messenger messenger001 = new Messenger(service);
            Message message = new Message();
            Bundle bundle = new Bundle();
            bundle.putString("a","i am client!");
            message.what=0;
            message.setData(bundle);
            try {
                messenger001.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            try {
                service.linkToDeath(deathRecipient, 0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

服务端接收数据

public class AIDLService extends Service {

    private Messenger messenger = new Messenger(new messageHanler());
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        //getBinder返回一个messenger和其handler通信的binder
        return messenger.getBinder();
    }

    class messageHanler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            if(msg.what==0){
                String u1 = msg.getData().getString("a");
                Log.e("xxxxx", "Receive from client:" + u1);
            }
        }
    }
}

进程双方互相可以通信
客户端,相比较上面的代码做了一些修改,主要是引入了replyTo回复信使这个方法,客户端来创建这个回复Messenger,并把它通过message传递到服务端,服务端接收此messenger,通过它回复客户端的消息

    private Messenger messenger = new Messenger(new clientHandler());
    private class clientHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            if(msg.what==0){
                String u1 = msg.getData().getString("a");
                Log.e("xxxxx","receive from server:"+u1);
            }
        }
    }

    private ServiceConnection myserviceconnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //连接上服务的回调函数
            Log.e("xxxxx", name.getClassName());
            //从传过来的ibinder对象获取一个信使messenger对象
            Messenger messenger001 = new Messenger(service);
            Message message = Message.obtain(null, 0);
            Bundle bundle = new Bundle();
            bundle.putString("a","i am client!");
            message.setData(bundle);
            //设置客户端的handler
            message.replyTo = messenger;
            try {
                messenger001.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            try {
                service.linkToDeath(deathRecipient, 0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }

        }

服务端

    class messageHanler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            if(msg.what==0){
                //客户端的信使Messenger,通过客户端传过来的信使来发送消息
                Messenger client = msg.replyTo;
                String u1 = msg.getData().getString("a");
                Log.e("xxxxx", "Receive from client:" + u1);
                //从全局池中获取一个message对象,来防止重复创建,消耗内存
                Message message = Message.obtain(null, 0);
                Bundle bundle = new Bundle();
                bundle.putString("a","i am server and i will reply you after a few minutes");
                message.setData(bundle);
                try {
                    client.send(message);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }

AIDL

在上一篇已经说过,binder是在线程池中来处理多个进程的并发请求,所以在AIDL接口方法中考虑处理线程并发的情况,这样就引入了CopyOnWriteArrayList

CopyOnWriteArrayList

官方解释:是ArrayList的安全线程的变体,支持多线程并发读写操作(是由底层数组副本来实现的),最终返回的是ArrayList对象

  • A thread-safe variant of {@link java.util.ArrayList} in which all mutative
  • operations ({@code add}, {@code set}, and so on) are implemented by
  • making a fresh copy of the underlying array.

服务端(只需要把数据)

    private CopyOnWriteArrayList<Book> books = new CopyOnWriteArrayList<Book>();
    private final BookManager.Stub bookManager = new BookManager.Stub() {
        @Override
        public void addBooks(Book book) throws RemoteException {
            books.add(book);
        }

        @Override
        public List<Book> getBook() throws RemoteException {
            return books;
        }

    };

    @Override
    public void onCreate() {
        Log.e("xxxxx", "服务创建了");
        books.add(new Book(1,"第一本书"));
        books.add(new Book(2,"第二本书"));
        super.onCreate();
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        //getBinder返回一个messenger和其handler通信的binder
        return bookManager;
    }

客户端(连接到服务端进程上时):请求返回books(在服务端时,是CopyOnWriteArrayList类型)对象的类型,返回结果好是ArrayList

    private ServiceConnection myserviceconnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //连接上服务的回调函数
            Log.e("xxxxx", name.getClassName());
            bookManager = BookManager.Stub.asInterface(service);
            try {
                List<Book> books = (List<Book>) bookManager.getBook();
                Log.e("xxxxx","类名:" + books.getClass().getCanonicalName());
                Log.e("xxxxx","书库存书:" + books.toString());
            } catch (RemoteException e) {
                e.printStackTrace();
            }

            try {
                service.linkToDeath(deathRecipient, 0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

新需求:需要满足服务进程新增书籍后,希望接收相关书籍的客户进程可以接收到通知

  1. 创建一个新书通知功能的接口,这个接口是供服务端进程调用的
    这个接口为什么使用aidl文件来创建:aidl接口只能使用aidl接口,不能使用普通接口
import com.app.typicallifecycle.Book;

interface IOnNewBookArrived {
    void OnNewBookArrvied(in Book book);
}
  1. 添加两个新功能给用户端进程调用,用来选择是否启用通知服务
    为什么这里要将IOnNewBookArrived对象作为参数:客户端进程需要和服务端进程建立联系,通过在OnNewBookArrvied方法内部封装发送message到固定handler的方法
interface BookManager {

    void addBooks(in Book book);
    List<Book> getBook();
    void registerNewBookArrivedListener(IOnNewBookArrived listener);
    void unreregisterNewBookArrivedListener(IOnNewBookArrived listener);
}
  1. 客户端进程内实现这个OnNewBookArrvied方法的封装,并作为参数传给服务端进程来让服务端进程发送message进行提醒服务
public class MainActivity extends AppCompatActivity {

    private static final String TAG = "xxxxx";
    private static final int MESSAGE_NEWBOOK_ARRIVED = 1;

    private EditText editText;
    private Button button;
    private Button button1;
    private Context context =getGlobalContext.getContext();
    private BookManager bookManager;
    private Intent intent;

    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            if (msg.what==MESSAGE_NEWBOOK_ARRIVED){
                Log.e(TAG, "客户端收到新书新增通知!");
            }
        }
    };


    private ServiceConnection myserviceconnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //连接上服务的回调函数
            Log.e("xxxxx", name.getClassName());
            bookManager = BookManager.Stub.asInterface(service);
            try {
                List<Book> books = (List<Book>) bookManager.getBook();
                Log.e("xxxxx","类名:" + books.getClass().getCanonicalName());
                Log.e("xxxxx","书库存书:" + books.toString());
                //注册新书新增通知
                bookManager.registerNewBookArrivedListener(iOnNewBookArrived);
            } catch (RemoteException e) {
                e.printStackTrace();
            }

            try {
                service.linkToDeath(deathRecipient, 0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        /*
        实例化一个IOnNewBookArrived接口对象,作为参数返回到远程进程中,一旦远端进程有新的书籍对象新增,就会调用
        这个对象的方法,发送message消息,这边接收到就会弹出提示
         */
        private IOnNewBookArrived iOnNewBookArrived = new IOnNewBookArrived.Stub() {
            @Override
            public void OnNewBookArrvied(Book book) throws RemoteException {
                //发送消息到由getTarget方法指定的handler
                handler.obtainMessage(MESSAGE_NEWBOOK_ARRIVED, book).sendToTarget();
            }
        };

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.e("xxxxx", "onCreate: 活动创建");
        super.onCreate(savedInstanceState);
        editText = findViewById(R.id.editText);
        setContentView(R.layout.activity_main);
        button = findViewById(R.id.button);
        button1 = findViewById(R.id.removeservice);
        intent = new Intent("AIDLservice");
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                bindService(intent, myserviceconnection, BIND_AUTO_CREATE);
            }
        });

服务端进程,模拟每5秒增加一本书,来提醒所有开启提醒服务的客户进程

public class AIDLService extends Service {
    private String TAG = "xxxxx";
    private CopyOnWriteArrayList<Book> books = new CopyOnWriteArrayList<Book>();
    private CopyOnWriteArrayList<IOnNewBookArrived> listeners = new CopyOnWriteArrayList<IOnNewBookArrived>();
    private Messenger messenger = new Messenger(new messageHanler());
    private final BookManager.Stub bookManager = new BookManager.Stub() {
        @Override
        public void addBooks(Book book) throws RemoteException {
            books.add(book);
        }

        @Override
        public List<Book> getBook() throws RemoteException {
            return books;
        }

        @Override
        public void registerNewBookArrivedListener(IOnNewBookArrived listener) throws RemoteException {
            if(listeners.contains(listener)){
                Log.e(TAG, "已经注册过提醒服务了");
            }else{
                listeners.add(listener);
            }
        }

        @Override
        public void unreregisterNewBookArrivedListener(IOnNewBookArrived listener) throws RemoteException {
            if(listeners.contains(listener)){
                listeners.remove(listener);
                Log.e(TAG, "注销提醒服务成功!");
            }else {
                Log.e(TAG, "未找到需要注销的提醒服务");
            }
        }
    };

    @Override
    public void onCreate() {
        try {
            Log.e("xxxxx", "服务创建了");
            books.add(new Book(1,"第一本书"));
            books.add(new Book(2,"第二本书"));
            delayAddBook();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (RemoteException e) {
            e.printStackTrace();
        }
        super.onCreate();
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        //getBinder返回一个messenger和其handler通信的binder
        return bookManager;
    }

    private void delayAddBook() throws InterruptedException, RemoteException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=books.size(); i<20; i++){
                    try {
                        Thread.sleep(5000);
                        Book book = new Book(i, String.valueOf(i)+"号新书");
                        books.add(book);
                        newBookArrived(book);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    //添加新书,发起通知
    private void newBookArrived(Book book) throws RemoteException {
        if (listeners.size() != 0){
            for (int i=0; i<listeners.size(); i++){
                listeners.get(i).OnNewBookArrvied(book);
            }
        }
    }

出现新问题:点击返回键,出现异常,找不到该binder连接Unbind failed: could not find connection for android.os.BinderProxy@4a822e38
原因:客户进程传过去的对象iOnNewBookArrived不是同一个对象

    @Override
    protected void onDestroy() {
        Log.e("xxxxx", "onDestroy:销毁activity");
        try {
            bookManager.unreregisterNewBookArrivedListener(iOnNewBookArrived);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
        super.onDestroy();
    }
}

解决:使用RemoteCallbackList,专门负责清理跨进成回调接口对象,虽然跨进程传递对象,会生成两个不同的对象,但是他们是使用同一个Binder进行通信的,所以根据这个特点,注册的时候使用map的类型保存binder对象,和listener这个回调方法对象,注销的时候,根据binder对象,注销器所有的listener回调方法对象。当然如果存在回调的方法不止一个这种情况,他们将是不同的两个RemoteCallbackList对象

替换的代码有,这些接口对象都需要替换:

private CopyOnWriteArrayList<IOnNewBookArrived> listeners = new CopyOnWriteArrayList<IOnNewBookArrived>();
替换成:
private RemoteCallbackList<IOnNewBookArrived> listeners = new RemoteCallbackList<IOnNewBookArrived>();

都已经封装成方法,直接调用

        @Override
        public void registerNewBookArrivedListener(IOnNewBookArrived listener) throws RemoteException {
            if(listeners.contains(listener)){
                Log.e(TAG, "已经注册过提醒服务了");
            }else{
                listeners.add(listener);
            }
        }

        @Override
        public void unreregisterNewBookArrivedListener(IOnNewBookArrived listener) throws RemoteException {
            if(listeners.contains(listener)){
                listeners.remove(listener);
                Log.e(TAG, "注销提醒服务成功!");
            }else {
                Log.e(TAG, "未找到需要注销的提醒服务");
            }
        }
    };
替换成:
        @Override
        public void registerNewBookArrivedListener(IOnNewBookArrived listener) throws RemoteException {
            listeners.register(listener);
        }

        @Override
        public void unreregisterNewBookArrivedListener(IOnNewBookArrived listener) throws RemoteException {
            listeners.unregister(listener);
        }
    //添加新书,发起通知
    private void newBookArrived(Book book) throws RemoteException {
        if (listeners.size() != 0){
            for (int i=0; i<listeners.size(); i++){
                listeners.get(i).OnNewBookArrvied(book);
            }
        }
    }
替换成:
    //添加新书,发起通知
    private void newBookArrived(Book book) throws RemoteException {
        int listenerNumber = listeners.beginBroadcast();
        for(int i=0; i<listenerNumber; i++){
            listeners.getBroadcastItem(i).OnNewBookArrvied(book);
        }
    }

RemoteCallbackList工作原理

根据android艺术编程上的讲解,使用binder来查询回调方法对象,这里有一个问题,同一个binder对应多个回调,即同一个binder多个RemoteCallbackList对象,应该还有别的参数来帮助找到同一个binder下的不同对象

ContentProvider

注意几个点:
1.如果是在同一个应用上开启另一个进程的情况,是不用考虑这些属性的设置的,都可以访问
2.外部应用调用contentprovider,需要android:exported="true"、不要设权限,只要满足这两点,就可以跨进程调用contentprovider(经过测试:android5.0夜神模拟器)

现在写代码:一个接入SQLlit数据库的ContentProvider组件
1.首先要用到一个SQLiteOpenHelper类,官网介绍说这是一个帮助类,帮助数据库的创建和版本更新,所以说这个类是给应用自己用的,不是给用户提供访问接口的,毕竟用户需要的只需要增删该查接口,不是这些复杂的功能。

public class mSqlLiteHelper extends SQLiteOpenHelper {
    private static final String DATABASE_NAME = "book_provider.db";
    private static final int DATABASE_VERSION = 1;
    private static final String table_name_book = "book";
    private static final String table_name_user = "user";


    private String create_table_book = "CREATE TABLE IF NOT EXISTS "
            +table_name_book+ "_id INTEGER PRIMARY KEY, book_name TEXT)";
    private String create_table_user = "CREATE TABLE IF NOT EXISTS "
            +table_name_user+ "_id INTEGER PRIMARY KEY, username TEXT, sex INT";

    //实例化数据库对象的时候,传入名称、版本号
    public mSqlLiteHelper(@Nullable Context context, @Nullable String name, @Nullable SQLiteDatabase.CursorFactory factory, int version) {
        super(context, DATABASE_NAME, factory, DATABASE_VERSION);
    }


    //数据库第一次创建时调用,创建表格等初始化操作
    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(create_table_book);
        db.execSQL(create_table_user);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    }
}

2.使用这个类创建好数据库之后,就可以使用ContentProvider将需要对外提供的数据库,开放其接口,但是ContentProvider需要访问Uri地址,所以需要给数据库生成一个Uri地址

注意几个小问题:

  1. context对象,一般从oncreate中使用getContext方法获取,组件创建的时候,生成相应的上下文环境(可以看作组件对象)
  2. SQL语句书写是注意单词之间留空格
    mContentProvider.java:使用mSqlLiteHelper类,生成、访问、更改数据库,作为对外开放的接口
public class mContentProvider extends ContentProvider {
    private static final String HOST = "com.app.typicallifecycle.provider";
    private static final String TAG = "xxxxx";
    private static final int uri_book_code = 0;
    private static final int uri_user_code = 1;
    private static Context mcontext;
    private static SQLiteDatabase sqLiteDatabase = null;
    String table_name = null;

    private static mContentObserver contentObserver = new mContentObserver(handler);;

    //生成两个Uri
    private static UriMatcher uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
    static {
        uriMatcher.addURI(HOST, "book", uri_book_code);
        uriMatcher.addURI(HOST, "user", uri_user_code);
    }
    private static final Uri uri_book = Uri.parse("content://"+HOST+ "/book");
    private static final Uri uri_user = Uri.parse("content://"+HOST+ "/user");


    /**
     * 根据传入的Uri对象,获取uri code,然后根据这个code,来匹配相应的数据库表
     *
     * @ param uriobject 传入的uri对象
     * @ return table name 数据库表的名称
     */
    private String getTableName(Uri uri){
        String table_name = null;
        switch (uriMatcher.match(uri)){
            case uri_book_code:
                table_name = mSqlLiteHelper.table_name_book;
                break;
            case uri_user_code:
                table_name = mSqlLiteHelper.table_name_user;
                break;
                default:break;
        }
        return table_name;
    }


    /**
     * 数据库的初始化操作.
     * 创建数据库、表。向表内插入数据
     *
     * @return database object 一个数据库对象
     */
    private void init_database(){
        sqLiteDatabase = new mSqlLiteHelper(mcontext).getWritableDatabase();
        sqLiteDatabase.execSQL("delete from " + mSqlLiteHelper.table_name_book);
        sqLiteDatabase.execSQL("delete from " + mSqlLiteHelper.table_name_user);
        sqLiteDatabase.execSQL("insert into " + mSqlLiteHelper.table_name_book + " values(1, 'Android');");
        sqLiteDatabase.execSQL("insert into " + mSqlLiteHelper.table_name_book + " values(2, 'IOS');");
        sqLiteDatabase.execSQL("insert into " + mSqlLiteHelper.table_name_user + " values(1, '安卓', 1);");
        sqLiteDatabase.execSQL("insert into " + mSqlLiteHelper.table_name_user + " values(2, '乔布斯', 1);");
    }

    @Override
    public boolean onCreate() {
        mcontext = getContext();
        init_database();
        return true;
    }

    @Nullable
    @Override
    public Cursor query(@NonNull Uri uri, @Nullable String[] projection, @Nullable String selection,
                        @Nullable String[] selectionArgs, @Nullable String sortOrder) {
        Log.e(TAG, "Current Thread:"+Thread.currentThread().getName());
        table_name = getTableName(uri);
        if(table_name!=null)
            return sqLiteDatabase.query(table_name, projection, selection, selectionArgs, null,
                    null, sortOrder, null);
        else throw new IllegalArgumentException("Illegal Uri: "+uri);
    }

    @Nullable
    @Override
    public String getType(@NonNull Uri uri) {
        return null;
    }

    @Nullable
    @Override
    public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
        table_name = getTableName(uri);
        if (uri==null){
            throw new Resources.NotFoundException("Not found this URI: "+uri);
        }
        Log.e(TAG, table_name);
        sqLiteDatabase.insert(table_name, null, values);
        Log.e(TAG, "OldURI:" + uri);
        getContext().getContentResolver().notifyChange(uri, null);
        Log.e(TAG, "New Uri: "+uri);
        return uri;
    }

    @Override
    public int delete(@NonNull Uri uri, @Nullable String selection, @Nullable String[] selectionArgs) {
        table_name = getTableName(uri);
        if (uri==null){
            throw new Resources.NotFoundException("Not found this URI: "+uri);
        }
        int deleted_number = sqLiteDatabase.delete(table_name, selection, selectionArgs);
        Log.e(TAG, "删除了:"  + String.valueOf(deleted_number) + " 行数据");
        //通知注册了ContentObserver的对象,此URI发生了更改
        getContext().getContentResolver().notifyChange(uri, null);
        return deleted_number;
    }

    @Override
    public int update(@NonNull Uri uri, @Nullable ContentValues values, @Nullable String selection, @Nullable String[] selectionArgs) {
        table_name = getTableName(uri);
        if (uri==null){
            throw new Resources.NotFoundException("Not found this URI: "+uri);
        }
        int updata_number = sqLiteDatabase.update(table_name, values, selection, selectionArgs);
        Log.e(TAG, "修改了" + String.valueOf(updata_number)+ "行数据");
        return updata_number;
    }
}

mContentObserver.java

package com.app.typicallifecycle;

import android.database.ContentObserver;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

public class mContentObserver extends ContentObserver {
    private static final String TAG = "xxxxx";
    private static int URI_ONCHANGED = 0;
    private static Handler mhandler;


    /**
     * Creates a content observer.
     *
     * @param handler The handler to run {@link #onChange} on, or null if none.
     */
    public mContentObserver(Handler handler) {
        super(handler);
        mhandler = handler;
    }

    @Override
    public void onChange(boolean selfChange) {
        Log.e(TAG, "uri 发生了更改");
       mhandler.obtainMessage(URI_ONCHANGED).sendToTarget();
        super.onChange(selfChange);
    }
}

MainActivity.java:跨进成访问ContentProvider

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.e("xxxxx", "onCreate: 活动创建");
        super.onCreate(savedInstanceState);
        editText = findViewById(R.id.editText);
        setContentView(R.layout.activity_main);
        button = findViewById(R.id.button);
        button1 = findViewById(R.id.removeservice);
        intent = new Intent("AIDLservice");
        new String();
        RemoteCallbackList<IUnregisterNotification> remoteCallbackList = new RemoteCallbackList<IUnregisterNotification>();
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Uri uri = Uri.parse("content://com.app.typicallifecycle.provider/book");
                Cursor cursor = getContentResolver().query(uri, null, null, null, null);
                user u1 = new user();
                while(cursor.moveToNext()){
                    u1.id = cursor.getInt(0);
                    u1.book_name = cursor.getString(1);
                    Log.e(TAG, "查询编号为:"+String.valueOf(u1.getId()) + ",书籍名称:"+u1.getBook_name());
                }
                registerObserver(uri);
                ContentValues contentValues = new ContentValues();
                contentValues.put("_id", 3);
                contentValues.put("book_name", "第一行代码");
                getContentResolver().insert(uri, contentValues);
                getContentResolver().delete(uri, "_id=?", new String[]{"3"});
                ContentValues newcontentValues = new ContentValues();
                newcontentValues.put("_id", 1);
                newcontentValues.put("book_name", "第二行代码");
                getContentResolver().update(uri, newcontentValues, "_id=1", null);

            }
        });

    private void registerObserver(Uri uri){
        contentObserver = new mContentObserver(new Handler(){
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what){
                    case 0:
                        Log.e(TAG, "ContentObserver: 接受到了来自跨进成的消息");
                        break;
                        default:break;
                }
            }
        });
        getContentResolver().registerContentObserver(uri, false, contentObserver);
    }
数据库小技能:数据导入脚本 背景:版本大升级,从2.0升级到3.0 ,服务端开发语言从c#换到java语言。数据库类型从microsalft sql server 换到mysql。数据来源于微信,用于查询卡bin。 阅读详情

相关推荐

机器人路径规划:基于冠豪猪优化算法(Crested Porcupine Optimizer,CPO)的机器人路径规划(提供MATLAB代码)

移动机器人(Mobile robot,MR)的路径规划是 移动机器人研究的重要分支之,是对其进行控制的基础。根据环境信息的已知程度不同,路径规划分为基于环境信息已知的全局路径规划和基于环境信息未知或局部已知的局部路径规划。随着科技的快速发展以及机器人的大量应用,人们对机器人的要求也越来越高,尤其表现在对机器人的智能化方面的要求,而机器人自主路径规划是实现机器人智能化的重要步骤,路径规划是指规划机器人从起点位置出发,无碰撞、安全到达指定目标位置的最优路径。

IT猿手 1368

008-Android-服务习题

选择题 关于AIDL说法正确的是( B) A、AIDL语言是java语言的演变 B、IPC全称是Interface process communication,AIDL语言可以解决进程间通信 C、AIDL语言语法复杂,学习成本高 D、以上说法都不正确 Context.startService方式的service生命周期下面正确的描述是(A ). A、启动时 onCreate() –> onStart() B、停止时,onStop()–> onDestroy() C、启动时 onCreate(

qq_46801776的博客 3621

S32K344 Flash Driver实战:手把手教你实现任意字节写入与扇区解锁(含C40_Ip避坑指南)

本文深入解析S32K344微控制器的Flash驱动开发,重点解决C40_Ip驱动库的8字节对齐限制和扇区保护锁问题。通过实战案例和代码示例,详细介绍了如何实现任意字节写入、扇区解锁及性能优化策略,为Bootloader和OTA升级等应用提供可靠解决方案。

weixin_33713707的博客 434

Android Binder组合ContentProvider跨进程调用,html5移动端开发教程

接下来通过一个实例来看看怎么具体地借助 ContentProvider 和 Binder 来进行便捷的跨进程通信。 Server进程 服务端接口定义 在服务端进程或者服务端 App 中,定义 AIDL 接口文件: interface IMyAidlInterface { int getCount(); } make 之后实现接口: class CountServiceImpl : IMyAidlInterface.Stub() { override fun getCount(): Int { println

wa2231a的博客 2521

国产麒麟系统各版本镜像下载

以上各链接均为迅雷下载,禁止商业用途!

2302_79474754的博客 6165

从Simulink仿真到DSP28335真机部署:PID闭环控制快速移植指南

本文详细介绍了如何将Simulink中的PID闭环控制算法快速移植到DSP28335嵌入式平台。通过模型与代码映射、浮点与定点数选择、定时器中断配置、物理输出实现以及调试技巧五个关键步骤,帮助工程师高效完成从仿真到真机部署的全过程,特别适合需要实现精确控制的嵌入式开发者。

weixin_42521843的博客 364

Android开发艺术探索——第二章:IPC机制(上)

Android开发艺术探索——第二章:IPC机制(上) 本章主要讲解Android的IPC机制,首先介绍Android中的多进程概念以及多进程开发模式中常见的注意事项,接着介绍Android中的序列化机制和Binder,然后详细的介绍Bundle,文件共享,AIDL,Messenger,ContentProvider和Sock...

weixin_34413802的博客 441

剑灵解包器修改xml.dat文件修改乳量方法

本篇内容是基于单机版网游改单机版游戏剑灵的内容,主要针对关于单机版进行数据修改,当然了对于网端有关于剑灵已有很多,像小助手等多种可以更改,但是存在有封号危险,好,下面我们是在单机版中来进行乳量的修改教程。

灵魂学者的博客 3338

《Android开发艺术探索》完结篇

笔记链接: 《Android开发艺术探索》之Activity的生命周期和启动模式(一) 《Android开发艺术探索》之IPC机制上(二) 《Android开发艺术探索》之IPC机制下(三) 《Android开发艺术探索》之View的事件体系(四) 《Android开发艺术探索》之View的工作原理(五) 《Android开发艺术探索》之理解RemoteViews、BroadCastR...

云瀚的自习室 3373

Android AMS——AMS初始化(二)

Android AMS 也是一个系统服务,属于系统服务中的引导服务,在 startBootstrapServices() 方法中启动。这里我们就来看一下 ActivityManagerService 的启动流程。

小旭的专栏 779

PyTorch生成式人工智能——VQ-VAE详解与实现

VQ-VAE (Vector Quantised-Variational AutoEncoder) 的核心思想就是将 VAE 的连续潜变量离散化。它通过学习一个码本 (Codebook) 来实现这一点,码本是一个包含有限个嵌入向量的字典。模型不是直接输出一个连续的潜在向量,而是从码本中找出与编码器输出最接近的嵌入向量来代替它。本节首先详细讲解 VQ-VAE 的技术原理,然后使用 PyTorch 从零开始实现 VQ-VAE 模型。

盼小辉丶的博客 3380

Android中常见IPC方法总结

IPC (Interprocess communication)跨进程通信,是指在两个进程之间交换数据的过程。多进程通信一般分为两种情况。第一种,一个应用因为自身的需要采用多进程实现,比如某些模块由于特殊原因需要运行在单独的进程中。第二种情况,当前应用需要获得其它应用的数据,由于是两个应用,所以必须采用跨进程的方式。下面就对常用的IPC方法做一个总结。 1、使用Bundle Activ

qq_30784675的博客 692

人工智能训练师三级考试题型全解析|190道真题样例+30天备考路线

人工智能训练师三级考试并不神秘:理论考190道选择题(刷题就能过),实操考代码+方案设计(练练就会)。核心是花时间——30天系统备考,足以从容通过。如果你想从零开始系统备考,覆盖所有考点和实操技能,欢迎查看我的专栏:📖《人工智能训练师三级·从零到拿证完全指南》80篇系统化内容,覆盖报名、备考、冲刺、拿证全流程六大模块知识点逐个击破,每个考点都讲透实操代码题手把手教学,附带完整参考代码高频考点速记 + 易错题精讲 + 3套模拟试卷30天备考计划 + 冲刺复习策略。

白话机器学习 6110

Android中常见IPC方法总结——Android开发艺术探索笔记

IPC (Interprocess communication)跨进程通信,是指在两个进程之间交换数据的过程。多进程通信一般分为两种情况。第一种,一个应用因为自身的需要采用多进程实现,比如某些模块由于特殊原因需要运行在单独的进程中。第二种情况,当前应用需要获得其它应用的数据,由于是两个应用,所以必须采用跨进程的方式。下面就对常用的IPC方法做一个总结。

SparkYuan 2248

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

android中的常用方法,Android中常见IPC方法总结

IPC (Interprocess communication)跨进程通信,是指在两个进程之间交换数据的过程。多进程通信一般分为两种情况。第一种,一个应用因为自身的需要采用多进程实现,比如某些模块由于特殊原因需要运行在单独的进程中。第二种情况,当前应用需要获得其它应用的数据,由于是两个应用,所以必须采用跨进程的方式。下面就对常用的IPC方法做一个总结。使用BundleActivity,Servic...

weixin_39984442的博客 195

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

Android IPC机制(二):AIDL的基本使用方法

一、前言 上一篇博客,讲述了实现序列化和反序列化的基本方式,是实现进程间通讯的必要条件,而这篇博客主要来讲一讲AIDL,通过展示AIDL的基本使用方法来引出IPC的核心:Binder。 二、什么是AIDL? AIDL全称:Android Interface Definition Language,即Android接口定义语言。由于不同的进程不能共享内存,所以为了解决进程间通讯的问题,

蓝天白云梦的csdn博客 1890

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Android跨进程(IPC)通信方法总结!!!

Android IPC方法总结1. Bundle2. 文件共享File3. AIDL4.Messenger5.ContentProvider6.Socket 1. Bundle     Bundle是Android中提供的用于携带数据通信的类,优点是简单易用,但只能传输基本类型的数据和实现了Parcelable或Serializable接口的对象,及Android中一些特殊的对象。 2. 文件共享File     通过使用Jav

LeeDuoZuiShuai的博客 655

一篇文章读懂Android组件之间数据传递方法 IPC进程通信方法AIDL介绍

思路 1通过共享appication做处理 2 先转换成json,第二个activity再转换回list 3 Parcelable Serializable  public class SerializableMap implements Serializable {       ArrayList> listMap;     //get set方法 } 最后通过putSeri

郭风朴(guofengpu)的Android影音专栏 1277

[Android]IPC通信之Messenger的使用方法介绍

Messenger(信使)是一种轻量级的IPC(Inter-Process Communication)实现方案,它的底层实现是AIDL(Android Interface Definition Language)。具体的应用中涉及到的类包括:Messenger和Message。 Messenger类的源代码如下:package android.os;public final class Mess

Forgive Me 585

2024年最新Android跨进程(IPC)通信方法总结!!!(1),2024年最新2024最新腾讯Android高级面试题总结

在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。附上:我们之前因为秋招收集的二十套一二线互联网公司Android面试真题(含BAT、小米、华为、美团、滴滴)和我自己整理Android复习笔记(包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。

2401_84558406的博客 849

android中IPC机制简介

除了Binder,Android还支持Socket,通过Socket也可以实现任意两个终端之间的通信,当然同一个设备上的两个进程通过Socket通信也自然是可以的。什么是进程,进程和线程是截然不同的概念。按照操作系统中的描述,线程是cpu调度最小的单元,同时线程是一个有限的系统资源。IPC是Inter-Process Communication的缩写,含义为进程间通信或者跨进程通信,是指两个进程间进行数据交换的过程。最简单情况下,一个进程中可以只有一个线程,即主线程,安卓中为UI线程。

Ueming的博客 1706

AIDL/IPC Android AIDL/IPC 进程通信机制——超具体解说及使用方法案例剖析(播放器)...

首先引申下AIDL。什么是AIDL呢?IPC? ------ Designing a Remote Interface Using AIDL 通常情况下,我们在同一进程内会使用Binder、BroadCastReciver让Service跟Activity进行通信。数据交互,数据共享。可是跨进程呢? IPC:IPC接口,IPC接口本地代理  ------  Implementing I...

weixin_34111790的博客 136

android机制使用方法,Android IPC机制(二):AIDL的基本使用方法

一、前言上一篇文章,讲述了实现序列化和反序列化的基本方式,是实现进程间通讯的必要条件,而这篇文章主要来讲一讲IPC的主要方式之一——AIDL方式。除了AIDL方式,IPC还有其他进程间通讯方式,比如Messager、ContentProvider、Socket等,这些以后会讲到。现在先说说AIDL的基本使用方法。二、什么是AIDL?AIDL全称:Android Interface Definiti...

weixin_42543046的博客 190
上一篇: 解压文件
下一篇: ARM之反弹shell
Dr. 熊
博客等级 码龄10年 29粉丝 140原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值