Android IPC通信--具体方式及实现

最新推荐文章于 2023-06-05 06:30:00 发布
最新推荐文章于 2023-06-05 06:30:00 发布
阅读量487 收藏 1
点赞数 1
分类专栏： Android开发
原文链接：https://github.com/yangchong211
版权

目录

01.使用Intent

02.使用文件共享

03.使用Messenger

04.使用AIDL

05.使用ContentProvider

06.使用Socket

07.各个方式的比较 

本文对Android中的IPC方式进行了具体的介绍与实现，若想了解更为基础的概念，请移步：Android IPC通信基础介绍

01.使用Intent

  • 1.Activity，Service，Receiver 都支持在 Intent 中传递 Bundle 数据，而 Bundle 实现了 Parcelable 接口，可以在不同的进程间进行传输。
  • 2.在一个进程中启动了另一个进程的 Activity，Service 和 Receiver ，可以在 Bundle 中附加要传递的数据通过 Intent 发送出去。

02.使用文件共享

  • 1.Windows 上，一个文件如果被加了排斥锁会导致其他线程无法对其进行访问，包括读和写；而 Android 系统基于 Linux ，使得其并发读取文件没有限制地进行，甚至允许两个线程同时对一个文件进行读写操作，尽管这样可能会出问题。
  • 2.可以在一个进程中序列化一个对象到文件系统中，在另一个进程中反序列化恢复这个对象（注意：并不是同一个对象，只是内容相同。）。
  • 3.SharedPreferences 是个特例，系统对它的读 / 写有一定的缓存策略，即内存中会有一份 ShardPreferences 文件的缓存，系统对他的读 / 写就变得不可靠，当面对高并发的读写访问，SharedPreferences 有很多大的几率丢失数据。因此，IPC 不建议采用 SharedPreferences。

03.使用Messenger

  • Messenger 是一种轻量级的 IPC 方案，它的底层实现是 AIDL ，可以在不同进程中传递 Message 对象，它一次只处理一个请求，在服务端不需要考虑线程同步的问题，服务端不存在并发执行的情形。
  • 服务端进程：
    • 服务端创建一个 Service 来处理客户端请求，同时通过一个 Handler 对象来实例化一个 Messenger 对象，然后在 Service 的 onBind 中返回这个 Messenger 对象底层的 Binder 即可。
    public class MessengerService extends Service {

    private static final String TAG = MessengerService.class.getSimpleName();

    private class MessengerHandler extends Handler {

        /**
         * @param msg
         */
        @Override
        public void handleMessage(Message msg) {

            switch (msg.what) {
                case Constants.MSG_FROM_CLIENT:
                    Log.d(TAG, "receive msg from client: msg = [" + msg.getData().getString(Constants.MSG_KEY) + "]");
                    Toast.makeText(MessengerService.this, "receive msg from client: msg = [" + msg.getData().getString(Constants.MSG_KEY) + "]", Toast.LENGTH_SHORT).show();
                    Messenger client = msg.replyTo;
                    Message replyMsg = Message.obtain(null, Constants.MSG_FROM_SERVICE);
                    Bundle bundle = new Bundle();
                    bundle.putString(Constants.MSG_KEY, "我已经收到你的消息，稍后回复你！");
                    replyMsg.setData(bundle);
                    try {
                        client.send(replyMsg);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    private Messenger mMessenger = new Messenger(new MessengerHandler());


    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
}

     

  • 客户端进程：
    • 首先绑定服务端 Service ，绑定成功之后用服务端的 IBinder 对象创建一个 Messenger ，通过这个 Messenger 就可以向服务端发送消息了，消息类型是 Message 。如果需要服务端响应，则需要创建一个 Handler 并通过它来创建一个 Messenger（和服务端一样），并通过 Message 的 replyTo 参数传递给服务端。服务端通过 Message 的 replyTo 参数就可以回应客户端了。
    public class MainActivity extends AppCompatActivity {
    private static final String TAG = MainActivity.class.getSimpleName();
    private Messenger mGetReplyMessenger = new Messenger(new MessageHandler());
    private Messenger mService;

    private class MessageHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case Constants.MSG_FROM_SERVICE:
                    Log.d(TAG, "received msg form service: msg = [" + msg.getData().getString(Constants.MSG_KEY) + "]");
                    Toast.makeText(MainActivity.this, "received msg form service: msg = [" + msg.getData().getString(Constants.MSG_KEY) + "]", Toast.LENGTH_SHORT).show();
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }



    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

    }

    public void bindService(View v) {
        Intent mIntent = new Intent(this, MessengerService.class);
        bindService(mIntent, mServiceConnection, Context.BIND_AUTO_CREATE);
    }

    public void sendMessage(View v) {
        Message msg = Message.obtain(null,Constants.MSG_FROM_CLIENT);
        Bundle data = new Bundle();
        data.putString(Constants.MSG_KEY, "Hello! This is client.");
        msg.setData(data);
        msg.replyTo = mGetReplyMessenger;
        try {
            mService.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }

    }

    @Override
    protected void onDestroy() {
        unbindService(mServiceConnection);
        super.onDestroy();
    }

    private ServiceConnection mServiceConnection = new ServiceConnection() {
        /**
         * @param name
         * @param service
         */
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = new Messenger(service);
            Message msg = Message.obtain(null,Constants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString(Constants.MSG_KEY, "Hello! This is client.");
            msg.setData(data);
            //
            msg.replyTo = mGetReplyMessenger;
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }

        }

        /**
         * @param name
         */
        @Override
        public void onServiceDisconnected(ComponentName name) {


        }
    };
}

     

  • **注意：**客户端和服务端是通过拿到对方的 Messenger 来发送 Message 的。
    • 客户端通过 bindService onServiceConnected 而服务端通过 message.replyTo 来获得对方的 Messenger 。Messenger中有一个Hanlder以串行的方式处理队列中的消息。不存在并发执行，因此我们不用考虑线程同步的问题。

04.使用AIDL

  • Messenger 是以串行的方式处理客户端发来的消息，如果大量消息同时发送到服务端，服务端只能一个一个处理，所以大量并发请求就不适合用Messenger，而且Messenger只适合传递消息，不能跨进程调用服务端的方法。
  • AIDL 可以解决并发和跨进程调用方法的问题，要知道Messenger本质上也是AIDL，只不过系统做了封装方便上层的调用而已。

4.1 AIDL文件支持的数据类型

  • 基本数据类型；
  • String 和 CharSequence
  • String
  • ArrayList ，里面的元素必须能够被 AIDL 支持；
  • HashMap ，里面的元素必须能够被 AIDL 支持；
  • Parcelable ，实现 Parcelable 接口的对象； 注意：如果 AIDL 文件中用到了自定义的 Parcelable 对象，必须新建一个和它同名的 AIDL 文件。
  • AIDL ，AIDL 接口本身也可以在 AIDL 文件中使用。

4.2 服务端

  • 服务端创建一个 Service 用来监听客户端的连接请求，然后创建一个 AIDL 文件，将暴露给客户端的接口在这个 AIDL 文件中声明，最后在 Service 中实现这个 AIDL 接口即可。

4.3客户端

  • 绑定服务端的 Service ，绑定成功后，将服务端返回的 Binder 对象转成 AIDL 接口所属的类型，然后就可以调用 AIDL 中的方法了。客户端调用远程服务的方法，被调用的方法运行在服务端的 Binder 线程池中，同时客户端的线程会被挂起，如果服务端方法执行比较耗时，就会导致客户端线程长时间阻塞，导致 ANR 。客户端的 onServiceConnected 和 onServiceDisconnected 方法都在 UI 线程中。

05.使用ContentProvider

  • 用于不同应用间数据共享，和 Messenger 底层实现同样是 Binder 和 AIDL，系统做了封装，使用简单。
  • 系统预置了许多 ContentProvider ，如通讯录、日程表，需要跨进程访问。使用方法：继承 ContentProvider 类实现 6 个抽象方法，这六个方法均运行在 ContentProvider 进程中，除 onCreate 运行在主线程里，其他五个方法均由外界回调运行在 Binder 线程池中。ContentProvider 的底层数据，可以是 SQLite 数据库，可以是文件，也可以是内存中的数据。
  • 详见代码： 
    public class BookProvider extends ContentProvider {
    private static final String TAG = "BookProvider";
    public static final String AUTHORITY = "com.jc.ipc.Book.Provider";

    public static final Uri BOOK_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/book");
    public static final Uri USER_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/user");

    public static final int BOOK_URI_CODE = 0;
    public static final int USER_URI_CODE = 1;
    private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);

    static {
        sUriMatcher.addURI(AUTHORITY, "book", BOOK_URI_CODE);
        sUriMatcher.addURI(AUTHORITY, "user", USER_URI_CODE);
    }

    private Context mContext;
    private SQLiteDatabase mDB;

    @Override
    public boolean onCreate() {
        mContext = getContext();
        initProviderData();

        return true;
    }

    private void initProviderData() {
        //不建议在 UI 线程中执行耗时操作
        mDB = new DBOpenHelper(mContext).getWritableDatabase();
        mDB.execSQL("delete from " + DBOpenHelper.BOOK_TABLE_NAME);
        mDB.execSQL("delete from " + DBOpenHelper.USER_TABLE_NAME);
        mDB.execSQL("insert into book values(3,'Android');");
        mDB.execSQL("insert into book values(4,'iOS');");
        mDB.execSQL("insert into book values(5,'Html5');");
        mDB.execSQL("insert into user values(1,'haohao',1);");
        mDB.execSQL("insert into user values(2,'nannan',0);");

    }

    @Nullable
    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        Log.d(TAG, "query, current thread"+ Thread.currentThread());
        String table = getTableName(uri);
        if (table == null) {
            throw new IllegalArgumentException("Unsupported URI" + uri);
        }

        return mDB.query(table, projection, selection, selectionArgs, null, null, sortOrder, null);
    }

    @Nullable
    @Override
    public String getType(Uri uri) {
        Log.d(TAG, "getType");
        return null;
    }

    @Nullable
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        Log.d(TAG, "insert");
        String table = getTableName(uri);
        if (table == null) {
            throw new IllegalArgumentException("Unsupported URI" + uri);
        }
        mDB.insert(table, null, values);
        // 通知外界 ContentProvider 中的数据发生变化
        mContext.getContentResolver().notifyChange(uri, null);
        return uri;
    }

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        Log.d(TAG, "delete");
        String table = getTableName(uri);
        if (table == null) {
            throw new IllegalArgumentException("Unsupported URI" + uri);
        }
        int count = mDB.delete(table, selection, selectionArgs);
        if (count > 0) {
            mContext.getContentResolver().notifyChange(uri, null);
        }

        return count;
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        Log.d(TAG, "update");
        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 BOOK_URI_CODE:
                tableName = DBOpenHelper.BOOK_TABLE_NAME;
                break;
            case USER_URI_CODE:
                tableName = DBOpenHelper.USER_TABLE_NAME;
                break;
            default:
                break;
        }

        return tableName;

    }
}
  • DBOpenHelper代码如下所示 
    public class DBOpenHelper extends SQLiteOpenHelper {

    private static final String DB_NAME = "book_provider.db";
    public static final String BOOK_TABLE_NAME = "book";
    public static final String USER_TABLE_NAME = "user";

    private static final int DB_VERSION = 1;

    private String CREATE_BOOK_TABLE = "CREATE TABLE IF NOT EXISTS "
            + BOOK_TABLE_NAME + "(_id INTEGER PRIMARY KEY," + "name TEXT)";

    private String CREATE_USER_TABLE = "CREATE TABLE IF NOT EXISTS "
            + USER_TABLE_NAME + "(_id INTEGER PRIMARY KEY," + "name TEXT,"
            + "sex INT)";



    public DBOpenHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(CREATE_BOOK_TABLE);
        db.execSQL(CREATE_USER_TABLE);

    }

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

    }
}

     

  • 测试代码 
    public class ProviderActivity extends AppCompatActivity {
    private static final String TAG = ProviderActivity.class.getSimpleName();
    private TextView displayTextView;
    private Handler mHandler;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_provider);
        displayTextView = (TextView) findViewById(R.id.displayTextView);
        mHandler = new Handler();

        getContentResolver().registerContentObserver(BookProvider.BOOK_CONTENT_URI, true, new ContentObserver(mHandler) {
            @Override
            public boolean deliverSelfNotifications() {
                return super.deliverSelfNotifications();
            }

            @Override
            public void onChange(boolean selfChange) {
                super.onChange(selfChange);
            }

            @Override
            public void onChange(boolean selfChange, Uri uri) {
                Toast.makeText(ProviderActivity.this, uri.toString(), Toast.LENGTH_SHORT).show();
                super.onChange(selfChange, uri);
            }
        });




    }

    public void insert(View v) {
        ContentValues values = new ContentValues();
        values.put("_id",1123);
        values.put("name", "三国演义");
        getContentResolver().insert(BookProvider.BOOK_CONTENT_URI, values);

    }
    public void delete(View v) {
        getContentResolver().delete(BookProvider.BOOK_CONTENT_URI, "_id = 4", null);


    }
    public void update(View v) {
        ContentValues values = new ContentValues();
        values.put("_id",1123);
        values.put("name", "三国演义新版");
        getContentResolver().update(BookProvider.BOOK_CONTENT_URI, values , "_id = 1123", null);


    }
    public void query(View v) {
        Cursor bookCursor = getContentResolver().query(BookProvider.BOOK_CONTENT_URI, new String[]{"_id", "name"}, null, null, null);
        StringBuilder sb = new StringBuilder();
        while (bookCursor.moveToNext()) {
            Book book = new Book(bookCursor.getInt(0),bookCursor.getString(1));
            sb.append(book.toString()).append("\n");
        }
        sb.append("--------------------------------").append("\n");
        bookCursor.close();

        Cursor userCursor = getContentResolver().query(BookProvider.USER_CONTENT_URI, new String[]{"_id", "name", "sex"}, null, null, null);
        while (userCursor.moveToNext()) {
            sb.append(userCursor.getInt(0))
                    .append(userCursor.getString(1)).append(" ,")
                    .append(userCursor.getInt(2)).append(" ,")
                    .append("\n");
        }
        sb.append("--------------------------------");
        userCursor.close();
        displayTextView.setText(sb.toString());
    }
}

     

06.使用Socket

Socket起源于 Unix，而 Unix 基本哲学之一就是“一切皆文件”，都可以用“打开 open –读写 write/read –关闭 close ”模式来操作。Socket 就是该模式的一个实现，网络的 Socket 数据传输是一种特殊的 I/O，Socket 也是一种文件描述符。Socket 也具有一个类似于打开文件的函数调用： Socket()，该函数返回一个整型的Socket 描述符，随后的连接建立、数据传输等操作都是通过该 Socket 实现的。 常用的 Socket 类型有两种：流式 Socket（SOCK_STREAM）和数据报式 Socket（SOCK_DGRAM）。流式是一种面向连接的 Socket，针对于面向连接的 TCP 服务应用；数据报式 Socket 是一种无连接的 Socket ，对应于无连接的 UDP 服务应用。

  • Socket 本身可以传输任意字节流。谈到Socket，就必须要说一说 TCP/IP 五层网络模型：
    • 应用层：规定应用程序的数据格式，主要的协议 HTTP，FTP，WebSocket，POP3 等；
    • 传输层：建立“端口到端口” 的通信，主要的协议：TCP，UDP；
    • 网络层：建立”主机到主机”的通信，主要的协议：IP，ARP ，IP 协议的主要作用：一个是为每一台计算机分配 IP 地址，另一个是确定哪些地址在同一子网；
    • 数据链路层：确定电信号的分组方式，主要的协议：以太网协议；
    • 物理层：负责电信号的传输。
  • Socket 是连接应用层与传输层之间接口（API）。

5.1Client 端代码

  • 代码如下所示 
    public class TCPClientActivity extends AppCompatActivity implements View.OnClickListener{

    private static final String TAG = "TCPClientActivity";
    public static final int MSG_RECEIVED = 0x10;
    public static final int MSG_READY = 0x11;
    private EditText editText;
    private TextView textView;
    private PrintWriter mPrintWriter;
    private Socket mClientSocket;
    private Button sendBtn;
    private StringBuilder stringBuilder;
    private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_READY:
                    sendBtn.setEnabled(true);
                    break;
                case MSG_RECEIVED:
                    stringBuilder.append(msg.obj).append("\n");
                    textView.setText(stringBuilder.toString());
                    break;
                default:
                    super.handleMessage(msg);
            }

    }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.tcp_client_activity);
        editText = (EditText) findViewById(R.id.editText);
        textView = (TextView) findViewById(R.id.displayTextView);
        sendBtn = (Button) findViewById(R.id.sendBtn);
        sendBtn.setOnClickListener(this);
        sendBtn.setEnabled(false);
        stringBuilder = new StringBuilder();

        Intent intent = new Intent(TCPClientActivity.this, TCPServerService.class);
        startService(intent);

        new Thread(){
            @Override
            public void run() {
                connectTcpServer();
            }
        }.start();
    }


    private String formatDateTime(long time) {
        return new SimpleDateFormat("(HH:mm:ss)").format(new Date(time));
    }

    private void connectTcpServer() {
        Socket socket = null;
        while (socket == null) {
            try {
                socket = new Socket("localhost", 8888);
                mClientSocket = socket;
                mPrintWriter = new PrintWriter(new BufferedWriter(
                        new OutputStreamWriter(socket.getOutputStream())
                ), true);
                mHandler.sendEmptyMessage(MSG_READY);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // receive message
        BufferedReader bufferedReader = null;
        try {
            bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
        while (!isFinishing()) {
            try {
                String msg = bufferedReader.readLine();
                if (msg != null) {
                    String time = formatDateTime(System.currentTimeMillis());
                    String showedMsg = "server " + time + ":" + msg
                            + "\n";
                    mHandler.obtainMessage(MSG_RECEIVED, showedMsg).sendToTarget();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    @Override
    public void onClick(View v) {
        if (mPrintWriter != null) {
            String msg = editText.getText().toString();
            mPrintWriter.println(msg);
            editText.setText("");
            String time = formatDateTime(System.currentTimeMillis());
            String showedMsg = "self " + time + ":" + msg + "\n";
            stringBuilder.append(showedMsg);

        }

    }

    @Override
    protected void onDestroy() {
        if (mClientSocket != null) {
            try {
                mClientSocket.shutdownInput();
                mClientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        super.onDestroy();
    }
}

5.2 Server 端代码

  • 代码如下所示
  • public class TCPServerService extends Service {
    private static final String TAG = "TCPServerService";
    private boolean isServiceDestroyed = false;
    private String[] mMessages = new String[]{
            "Hello! Body!",
            "用户不在线！请稍后再联系！",
            "请问你叫什么名字呀？",
            "厉害了，我的哥！",
            "Google 不需要科学上网是真的吗？",
            "扎心了，老铁！！！"
    };


    @Override
    public void onCreate() {
        new Thread(new TCPServer()).start();
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        isServiceDestroyed = true;
        super.onDestroy();
    }

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

    private class TCPServer implements Runnable {

        @Override
        public void run() {
            ServerSocket serverSocket = null;
            try {
                serverSocket = new ServerSocket(8888);
            } catch (IOException e) {
                e.printStackTrace();
                return;
            }
            while (!isServiceDestroyed) {
                // receive request from client
                try {
                    final Socket client = serverSocket.accept();
                    Log.d(TAG, "=============== 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 {
        //receive message
        BufferedReader in = new BufferedReader(
                new InputStreamReader(client.getInputStream()));
        //send message
        PrintWriter out = new PrintWriter(
                new BufferedWriter(
                        new OutputStreamWriter(
                                client.getOutputStream())),true);
        out.println("欢迎来到聊天室！");

        while (!isServiceDestroyed) {
            String str = in.readLine();
            Log.d(TAG, "message from client: " + str);
            if (str == null) {
                return;
            }
            Random random = new Random();
            int index = random.nextInt(mMessages.length);
            String msg = mMessages[index];
            out.println(msg);
            Log.d(TAG, "send Message: " + msg);
        }
        out.close();
        in.close();
        client.close();

    }
}

     

07.各个方式的比较 

 

ipc

这里再对比总结一下：

  1. 只有允许不同应用的客户端用 IPC 方式调用远程方法，并且想要在服务中处理多线程时，才有必要使用 AIDL
  2. 如果需要调用远程方法，但不需要处理并发 IPC，就应该通过实现一个 Binder 创建接口
  3. 如果您想执行 IPC，但只是传递数据，不涉及方法调用，也不需要高并发，就使用 Messenger 来实现接口
  4. 如果需要处理一对多的进程间数据共享（主要是数据的 CRUD），就使用 ContentProvider
  5. 如果要实现一对多的并发实时通信，就使用 Socket
     

 

&岁月不待人&
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android使用Service实现IPC通信的2种方式
08-26
主要介绍了Android使用Service实现IPC通信的2种方式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Default Activity not found解决方法
weixin_44803759的博客
03-19 2175
项目场景： 最近开始学习Android，第一次尝试建立一个空白项目，手动添加activity时出现报错：Default Activity not found 问题描述： 运行时程序可以正常编译，但不能发布到AVD上，查看了几篇博文，发现这篇方法较全而且总结较好 https://blog.csdn.net/yforyoung/article/details/84952283 转载记录一下 原因分析： 原因可能有如下几种情况： AndroidManifest.xml文件中没有声明相应Activity，
Android IPC机制（五）用Socket实现跨进程聊天程序
陈柱的博客
03-13 234
1.Socket简介 Socket也称作“套接字“，是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用以实现进程在网络中通信。它分为流式套接字和数据包套接字，分别对应网络传输控制层的TCP和UDP协议。TCP协议是一种面向连接的、可靠的、基于字节流的传输层通信协议。它使用三次握手协议建立连接，并且提供了超时重传机制，具有很高的稳定性。UDP协议则是是...
《Android 开发艺术探索》笔记2--IPC机制
行动者&&职业化
09-03 1868
《Android 开发艺术探索》笔记2--IPC机制思维导图Android IPC简介Android中的多进程的模式IPC基础概念Serializable接口Parcelable接口Android的几种跨进程的方式使用Bundle使用文件共享使用Messenger使用AIDL各种IPC的差异以及选择参看文章 思维导图 Android IPC简介 IPC是Inter-Process Communication缩写,含义为进程间通信. 按照操作系统中的描述,线程是cpu调度的最小单元,而进程一般指一个执行单元
Android：IPC(进程间通信)机制
Tai_Monster的博客
05-22 1128
本篇文章里我们介绍了如何实现IPC，主要有使用AIDL，Bundle传输，使用文件共享和使用ContentProvider四种方法。名称优点缺点适用场景Bundle简单易用只能传输Bundle支持的数据类型四大组件间的进程间通信文件共享简单易用不适合高并发场景，并且无法做到进程间的即时通信无并发访问情形，交换简单的数据实时性不高的场景Messenger功能一般，支持一对多串行通信，支持实时通信。
解决default activity not found办法大全
热门推荐
海纳百川Android的博客
08-26 7万+
最近在项目中遇到一个问题，就是以前用android studio能正常打开的工程，今天突然报default activity not found错误，该错误导致app那块显示一个红叉，无法直接launch app，可以build工程产生apk文件，但是不能用studio直接launch app，这样对开发来讲还是很不方便的。正常情况下如下图 遇见该错误的时候如下图 进到Edit Con...
Default Activity not found
codehxy的专栏
10-12 778
1、Default Activity not found 很明显就是说找不到默认的Activity 首先检查是否正确配置了LAUNCHER <activity android:name="com.test.positive.affirmation.SplashActivity" android:screenOrientation="portrait"> <intent-filter>
Android中进程间通信(IPC)方式总结
gjnm820的博客
06-11 6463
IPC为进程间通信或跨进程通信，是指两个进程进行进程间通信的过程。在PC和移动设备上一个进程指的是一个程序或者一个应用，所以我们可以将进程间通信简单理解为不同应用之间的通信，当然这种说法并不严谨。       在Android中，为每一个应用程序都分配了一个独立的虚拟机，或者说每个进程都分配一个独立的虚拟机，不同虚拟机在内存分配上有不同的地址空间，这就导致在不同的虚拟机互相访问数据需要借助其他手
Android Framework跨进程通信IPC之4——AndroidIPC基础1
Gaga246的博客
06-05 424
进程Process 是程序的一个运行实例，以区别于"程序" 这一个静态概念；而线程(Thread) 则是CPU调度的单位。当前大部分操作系统都是支持多任务运行，这一特性让用户感到计算机好像可以同时处理很多事情。显然在只有一个CPU核心的情况下，这种"同时"是一种假象。它是操作系统先采用分时的方法，为正在运行的多任务分配合理的、单独的CPU来实现的。比如当前系统有5个任务，如果采用"平均分配"法且时间为10ms的话，那么各个任务每隔40ms就能被执行一次。
Android studio 安装真机报错“Default Activity not found“解决方案汇总
龙旋的博客
01-13 2807
跑了两年的项目，最近真机安装测试的时候遇到个问题，就是安装真机的时候，Android studio运行按钮无法使用，app前面的图标上方也出现了红色的叉叉，如图所示： 就是这样的啦，点击运行按钮后，还出现如下的错误信息： 这就有点尴尬了啊，跑了这么久的项目第一次遇到这样的问题，加上升级客服系统的时候改了一下配置，项目又催着测试了，还真是有点慌了啊，没办法，那得赶紧排查问题啊。 根据错误信息肯定先排查默认启动的Activity有没声明了，虽然知道应该不是这个问题，毕竟跑了这么久的项目了，那还是得检查一下啊
Android IPC通信 - AIDL.zip
12-11
Android中Service的进程通信方式 - AIDL入门实践
Android通信篇--深入剖析Binder原理
02-25
一般Android应用开发很少直接用到跨进程信通信（IPC），但如果你想知道：1.App是如何启动并初始化的？2.Activity的启动过程是怎样的？3.进程间是如何通信的？4.AIDL的具体原理是什么？5.众多插件化框架的设计原理...
Android-AndroidIPC多进程通信aidl
08-13
Android IPC多进程通信 aidl
浅谈Android开放网络端口的安全风险
键盘的起始页
10-12 1988
Android应用通常使用等不同domain的来进行本地IPC或者远程网络通信，这些暴露的socket代表了潜在的本地或远程攻击面，历史上也出现过不少利用socket进行拒绝服务、root提权或者远程命令执行的案例。特别是PF_INET。
Android平台GB28181设备接入端本地SIP端口被占用或屏蔽怎么办？
乐学吧
10-04 1119
好多开发者或厂商，对Android平台GB28181接入模块的定位，大多是IPC国标流程打通模拟，基于这个目的，很难按照标准SPEC规范实现Android平台GB28181设备接入，我们在跟第三方国标平台厂商对接时发现，部分公司，尽管参与了标准的制定或审校，自身实现，细节仍不尽人意。Android平台GB28181接入终端除支持常规的音视频数据接入外，还需要支持移动设备位置(MobilePosition)订阅和通知、语音广播和语音对讲。感兴趣的开发者，可以做下尝试。
十四 、 Android 中的 IPC 方式（6） --- 使用 Socket
丶一个有梦想的老实人 的博客
05-27 257
什么是Socket？ 两台计算机进行通信，在网络中我们可以通过 IP 地址定位到具体的某一台计算机，然后再通过端口号定位到这台计算机的某一个应用程序。这样我们的一台电脑就可以通过 IP 地址和端口号和另一台电脑进行相应的通讯了。那我们定位到了具体的某台计算机怎么和它进行相应的通信呢？他们之间的通信方式就是使用 Socket 提供的编程接口。Socket 称为 "套接字"，通俗的理...
淘宝抓包，直达函数内部request请求体和response响应体， 告别FD， Charles，SSL，justtrustme 等http代理，证书工具。
binary66的博客
04-12 3539
淘宝抓包，hook发包函数，直接获取response相应数据
Default Activity not found问题解决方案
逍遥阁
02-21 3150
1、今天运行一个android项目时候，一直报错说：Default Activity not found: 同时，Android Studio上也显示红色叉叉，没法正常编译 反复检查AndroidManifest.xml，里面确实已经声明了默认启动的Activity: 2、初步猜想：会不会是AS缓存导致的，尝试clean项目，然后同步一下，重新build一下，结果还是提示上述的错误 3、进一步猜想：会不会AS抽风了，之前偶尔会遇到这种情况，尝试点击刷新缓存重启一下AS, 然而还是报同样的错误 4、
六首页数字藏品NFT交易网React NextJS网站模板 六首页数字藏品nft交易网反应NextJS网站模板
最新发布
05-15
六首页数字藏品NFT交易网React NextJS网站模板 六首页数字藏品nft交易网反应NextJS网站模板
Android IPC
09-17
Android IPC（Inter-process Communication）是指在 Android 应用程序中不同进程之间进行通信的机制。Android 提供了多种 IPC 机制，包括：Intent、Binder、ContentProvider、Messenger 等。 其中最常用的是 Binder 机制，它是一种高效的进程间通信方式。Binder 通过提供跨进程的方法调用，使得不同进程之间可以像调用本地方法一样进行通信。在 Binder 机制中，包含服务端、客户端、Binder 驱动和 Binder 运行时四个主要组件。服务端在一个独立的进程中创建并提供服务，客户端通过 Binder 接口与服务端进行通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值