IPC机制--利用AIDL

最新推荐文章于 2020-09-17 14:04:02 发布
最新推荐文章于 2020-09-17 14:04:02 发布
阅读量258 收藏
点赞数
分类专栏： Android开发艺术探索读书笔记 Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27035123/article/details/58205828
版权

代码下载

全部代码下载连接：https://github.com/NoClay/MessagerTest.git

为什么使用AIDL？

我们之前使用Messenger实现了IPC，但是Messenger是一个接着一个处理的，对于大量的并发请求，那么用messenger就不太合适了，同时Messenger主要是为了传递消息，很多时候我们需要跨进程调用服务器的方法。

怎么使用AIDL进程进程间通信？

1. 服务端

服务端需要简历一个Service来监听客户端的连接请求，然后创建一个AIDL文件，将暴露在客户端的接口在这个AIDL文件中声明，最后在Service中实现这个AIDL接口即可。
BookManagerService.java

package com.example.no_clay.messagertest.Item244;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.os.RemoteException;

import com.example.no_clay.messagertest.Data.Book;
import com.example.no_clay.messagertest.Data.IBookManager;
import com.example.no_clay.messagertest.Data.IOnNewBookArrivedListener;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class BookManagerService extends Service {

    private CopyOnWriteArrayList<Book> mBooks = new CopyOnWriteArrayList<>();
    private CopyOnWriteArrayList<IOnNewBookArrivedListener> mListeners
            = new CopyOnWriteArrayList<>();
    Binder mBinder = new IBookManager.Stub() {
        @Override
        public List<Book> getBookList() throws RemoteException {
            return mBooks;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            onNewBookArrived(book);
        }

        @Override
        public void registerListener(IOnNewBookArrivedListener listener) throws RemoteException {

            if (!mListeners.contains(listener)){
                mListeners.add(listener);
            }
        }

        @Override
        public void unregisterListener(IOnNewBookArrivedListener listener) throws RemoteException {
            if (mListeners.contains(listener)){
                mListeners.remove(listener);
            }
        }
    };

    private void onNewBookArrived(Book book) {
        mBooks.add(book);
        for (IOnNewBookArrivedListener listener :
                mListeners) {
            try {
                listener.onNewBookArrivedListener(book);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void onCreate() {
        super.onCreate();
        mBooks.add(new Book("唯物主义", "num123"));
        mBooks.add(new Book("我也不知道是什么", "num143"));
    }

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

2. 客户端

客户端需要绑定服务端的Service，绑定成功后，将服务端反悔的Binder对象转狂欢为AIDL接口所属的类型，接着就可以调用AIDL中的方法。
BookManagerActivity.java

package com.example.no_clay.messagertest.Item244;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

import com.example.no_clay.messagertest.Data.Book;
import com.example.no_clay.messagertest.Data.IBookManager;
import com.example.no_clay.messagertest.Data.IOnNewBookArrivedListener;
import com.example.no_clay.messagertest.R;

import java.util.List;

public class BookManagerActivity extends AppCompatActivity {
    private static final String TAG = "BookManagerActivity";
    IBookManager mBookManager = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_book_manager);
        Intent intent = new Intent(this, BookManagerService.class);
        bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
    }

    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            IBookManager bookManager = IBookManager.Stub.asInterface(service);
            try {
                mBookManager = bookManager;
                bookManager.registerListener(listener);
                List<Book> list = bookManager.getBookList();
                Log.d(TAG, "onServiceConnected: list type = " + list.getClass().getCanonicalName());
                Log.d(TAG, "onServiceConnected: list = " + list.toString());
                bookManager.addBook(new Book("呵呵呵呵呵", "num1232"));
                list = bookManager.getBookList();
                Log.d(TAG, "onServiceConnected: list type = " + list.getClass().getCanonicalName());
                Log.d(TAG, "onServiceConnected: list = " + list.toString());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

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

    private IOnNewBookArrivedListener listener = new IOnNewBookArrivedListener.Stub(){

        @Override
        public void onNewBookArrivedListener(Book newBook) throws RemoteException {
            Log.d(TAG, "onNewBookArrivedListener: one book new = " + newBook.getName() + newBook.getId());
        }
    };

    @Override
    protected void onDestroy() {
        if (mBookManager != null && mBookManager.asBinder().isBinderAlive()){
            try {
                mBookManager.unregisterListener(listener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        unbindService(mServiceConnection);
        super.onDestroy();
    }


}

3. AIDL接口的创建

AIDL文件中，可以接受的数据类型为：
1. 基本数据类型（int/ long/ char/ boolean等）
2. String和CharSequence
3. List：只支持ArrayList，里面每个元素都必须能够被AIDL支持，例如CopyOnWriteArrayList（支持并发读、写），在Binder中会按照List的规范访问数据，并形成一个ArrayList
4. Map：只支持HashMap，里面的每个元素都必须被AIDL所支持，包括key和value，例如ConcurrentHashMap
5. Parcelable：支持所艘实现了Parcelable接口的对象
6. AIDL：所有的AIDL接口本身也可以在AIDL文件中使用

AIDL中的参数，除了基本类型，其它类型的参数都需要标上方向，如in， out或者inout。AIDL接口支持方法，但不支持静态变量
Book.aidl

// IBookManager.aidl
package com.example.no_clay.messagertest.Data;

// Declare any non-default types here with import statements

parcelable Book;

BookManager.aidl

// IBookManager.aidl
package com.example.no_clay.messagertest.Data;
import com.example.no_clay.messagertest.Data.Book;
import com.example.no_clay.messagertest.Data.IOnNewBookArrivedListener;
// Declare any non-default types here with import statements

interface IBookManager {
     List<Book> getBookList();
     void addBook(in Book book);
     void registerListener(IOnNewBookArrivedListener listener);
     void unregisterListener(IOnNewBookArrivedListener listener);
}

Listener.aidl

// IOnNewBookArrivedListener.aidl
package com.example.no_clay.messagertest.Data;
import com.example.no_clay.messagertest.Data.Book;
// Declare any non-default types here with import statements

interface IOnNewBookArrivedListener {
    void onNewBookArrivedListener(in Book newBook);
}

Book.java

package com.example.no_clay.messagertest.Data;

import android.os.Parcel;
import android.os.Parcelable;

/**
 * Created by no_clay on 2017/2/27.
 */

public class Book implements Parcelable{

    String name;
    String id;

    public Book(String name, String id) {
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }



    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeString(id);
    }

    protected Book(Parcel in) {
        name = in.readString();
        id = in.readString();
    }



    public static final Creator<Book> CREATOR = new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel in) {
            return new Book(in);
        }

        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };
}

But

上述中，我们采用CopyOnWriteArrayList来存储了OnNewBookArrivedListener的时候，我们将一个对象从一个进程传递到另一个进程，虽然注册和注销的时候使用的是同一个客户端对象，但是在两个进程中是两个不同的全新的对象，所以我们在上述代码实例注销的时候会出现：

02-27 19:57:16.270 1035-1035/com.example.no_clay.messagertest D/BookManagerActivity: onServiceConnected: list type = java.util.ArrayList
02-27 19:57:16.270 1035-1035/com.example.no_clay.messagertest D/BookManagerActivity: onServiceConnected: list = [com.example.no_clay.messagertest.Data.Book@42caa858, com.example.no_clay.messagertest.Data.Book@42caa8f0]
02-27 19:57:16.270 1035-1035/com.example.no_clay.messagertest D/BookManagerActivity: onNewBookArrivedListener: one book new = 呵呵呵呵呵num1232
02-27 19:57:16.271 1035-1035/com.example.no_clay.messagertest D/BookManagerActivity: onServiceConnected: list type = java.util.ArrayList
02-27 19:57:16.271 1035-1035/com.example.no_clay.messagertest D/BookManagerActivity: onServiceConnected: list = [com.example.no_clay.messagertest.Data.Book@42cab858, com.example.no_clay.messagertest.Data.Book@42cab8f0, com.example.no_clay.messagertest.Data.Book@42cab990]
02-27 19:57:20.925 1035-1035/com.example.no_clay.messagertest D/BookManagerActivity: onDestroy: unregister listener = com.example.no_clay.messagertest.Item244.BookManagerActivity$2@42c925f8
02-27 19:57:20.926 2386-2408/com.example.test D/BookManagerActivity: unregisterListener: not found the listener

怎么解决这个问题？

我们可以使用RemoteCallbackList，这个是系统专门提供的用于删除跨进程Listener的接口，它是一个泛型，可以管理任何的AIDL接口，其实它的内部实现基于Map接口，key为Binder类型，value为Callback类型，而Callback中封装了真正的远程listener。

    IBinder key = listener.asBinder();
    Callback value = new Callback(listener, cookie)

虽说我们跨进程传输了Listener，但其核心Binder还是不变的，我们可以利用这个类将listener保存起来，同时RemoteCallbackList内部自动实现了线程同步的功能， 所以我们使用它来进行注册和注销的时候，不需要做额外的线程同步。
注意：遍历RemoteCallbackList时beginBroadcast获取内部size，和finishBroadcast需要成对出现。
修改后的Service如下：

package com.example.no_clay.messagertest.Item244;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.util.Log;

import com.example.no_clay.messagertest.Data.Book;
import com.example.no_clay.messagertest.Data.IBookManager;
import com.example.no_clay.messagertest.Data.IOnNewBookArrivedListener;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;


public class BookManagerService extends Service {
    private static final String TAG = "BookManagerActivity";
    private CopyOnWriteArrayList<Book> mBooks = new CopyOnWriteArrayList<>();
    private RemoteCallbackList<IOnNewBookArrivedListener> mListeners
            = new RemoteCallbackList<>();
    Binder mBinder = new IBookManager.Stub() {
        @Override
        public List<Book> getBookList() throws RemoteException {
            return mBooks;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            onNewBookArrived(book);
        }

        @Override
        public void registerListener(IOnNewBookArrivedListener listener) throws RemoteException {
            mListeners.register(listener);
        }

        @Override
        public void unregisterListener(IOnNewBookArrivedListener listener) throws RemoteException {
            mListeners.unregister(listener);
            final int size = mListeners.beginBroadcast();
            Log.d(TAG, "unregisterListener: size = " + size);
            mListeners.finishBroadcast();
        }
    };

    private void onNewBookArrived(Book book) {
        mBooks.add(book);
        final int size = mListeners.beginBroadcast();
        for (int i = 0; i < size; i++) {
            IOnNewBookArrivedListener listener = mListeners.getBroadcastItem(i);
            try {
                listener.onNewBookArrivedListener(book);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        mListeners.finishBroadcast();
    }

    @Override
    public void onCreate() {
        super.onCreate();
        mBooks.add(new Book("唯物主义", "num123"));
        mBooks.add(new Book("我也不知道是什么", "num143"));
    }

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

注意

  1. 客户端的onServiceConnected和onServiceDisConnected方法都运行在UI线程中，所以不可以在它们礼拜内调用服务器的耗时方法
  2. 服务器端的方法本身运行在服务器的Binder线程池中，所以服务端方法本身可以执行大量耗时操作，这个时候切记不要在服务端开线程进行异步操作，除非你明确知道自己在干什么
  3. 服务端调用客户端中的listener的方法时，被调用的方法运行在客户端的Binder线程池中，所以同样不可以在服务端中调用客户端的耗时方法
  4. 客户端的listener方法运行在Binder线程池中，所以我们不能在里边进行UI操作，我们应该使用Handler切换到UI线程。

如何解决Binder的意外死亡

Binder通常会因为服务端进程意外停止，那么如何解决这种意外情况的出现呢？

1. 给Binder设置DeathRecipient死亡监听

当Binder死亡的时候，我们会收到binderDied方法的回调，在这个方法中我们可以重新连接远程服务， 具体方法如下：

package com.example.no_clay.messagertest.Item244;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

import com.example.no_clay.messagertest.Data.Book;
import com.example.no_clay.messagertest.Data.IBookManager;
import com.example.no_clay.messagertest.Data.IOnNewBookArrivedListener;
import com.example.no_clay.messagertest.R;

import java.util.List;

public class BookManagerActivity extends AppCompatActivity {
    private static final String TAG = "BookManagerActivity";
    IBookManager mBookManager = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_book_manager);
        Intent intent = new Intent(this, BookManagerService.class);
        bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
    }

    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            IBookManager bookManager = IBookManager.Stub.asInterface(service);
            try {
                mBookManager.asBinder().linkToDeath(mRecipient, 0);
                mBookManager = bookManager;
                bookManager.registerListener(listener);
                List<Book> list = bookManager.getBookList();
                Log.d(TAG, "onServiceConnected: list type = " + list.getClass().getCanonicalName());
                Log.d(TAG, "onServiceConnected: list = " + list.toString());
                bookManager.addBook(new Book("呵呵呵呵呵", "num1232"));
                list = bookManager.getBookList();
                Log.d(TAG, "onServiceConnected: list type = " + list.getClass().getCanonicalName());
                Log.d(TAG, "onServiceConnected: list = " + list.toString());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

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

    private IOnNewBookArrivedListener listener = new IOnNewBookArrivedListener.Stub(){

        @Override
        public void onNewBookArrivedListener(Book newBook) throws RemoteException {
            Log.d(TAG, "onNewBookArrivedListener: one book new = " + newBook.getName() + newBook.getId());
        }
    };

    @Override
    protected void onDestroy() {
        if (mBookManager != null && mBookManager.asBinder().isBinderAlive()){
            try {
                Log.d(TAG, "onDestroy: unregister listener = " + listener);
                mBookManager.unregisterListener(listener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        unbindService(mServiceConnection);
        super.onDestroy();
    }

    private IBinder.DeathRecipient mRecipient = new IBinder.DeathRecipient() {
        @Override
        public void binderDied() {
            if (mBookManager != null){
                mBookManager.asBinder().unlinkToDeath(mRecipient, 0);
                mBookManager = null;
                Intent intent = new Intent(BookManagerActivity.this
                        , BookManagerService.class);
                bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
            }
        }
    };

}

2. 在onServiceDisconnected中重新连接远程服务

这种方法极为简洁，故此不做说明。

对比：

·两种方法所艘在的进程不同，onServiceDisconnected在客户端的UI线程中被回调，binderDied在客户端的Binder线程池中被回调，也就是说在binderDied中我们不可以访问UI。

如何做远程服务的权限验证？

1.在onBind中验证：

首先我们需要在xml文件中声明所需要的权限：

    <permission
        android:name="com.example.no_clay.messagertest.permission
    .ACCESS_BOOK_MANAGER_SERVICE"
        android:protectionLevel="normal">

接着在onBind中进行权限验证，如果没有权限，则返回空

    @Override
    public IBinder onBind(Intent intent) {
        int check = checkCallingOrSelfPermission("com.example.no_clay.messagertest" +
                ".permission.ACCESS_BOOK_MANAGER_SERVICE");
        if (check == PackageManager.PERMISSION_DENIED){
            return null;
        }
        return mBinder;
    }

2. 在服务端的跨进程接口中的onTransact进行权限验证：

   Binder mBinder = new IBookManager.Stub() {

        @Override
        public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
            //利用Permission权限验证
            int check = checkCallingOrSelfPermission("com.example.no_clay.messagertest" +
                    ".permission.ACCESS_BOOK_MANAGER_SERVICE");
            if (check == PackageManager.PERMISSION_DENIED){
                return false;
            }
            //利用包名验证
            String packageName = null;
            String[] packages = getPackageManager()
                    .getPackagesForUid(getCallingUid());
            if (packages != null && packages.length > 0){
                packageName = packages[0];
            }
            if (!packageName.startsWith("com.example.no_clay")){
                return false;
            }
            return super.onTransact(code, data, reply, flags);
        }

        @Override
        public List<Book> getBookList() throws RemoteException {
            return mBooks;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            onNewBookArrived(book);
        }

        @Override
        public void registerListener(IOnNewBookArrivedListener listener) throws RemoteException {
            mListeners.register(listener);
        }

        @Override
        public void unregisterListener(IOnNewBookArrivedListener listener) throws RemoteException {
            mListeners.unregister(listener);
            final int size = mListeners.beginBroadcast();
            Log.d(TAG, "unregisterListener: size = " + size);
            mListeners.finishBroadcast();
        }
    };
NoClay
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android IPC通信 - AIDL.zip
12-11
在Android系统中，IPC（Inter-Process Communication）是不同应用程序之间进行数据交换和协同工作的重要机制。本资料包“Android IPC通信 - ...通过深入学习和实践，开发者可以更好地利用AIDL解决多进程间的通信问题。
Android AIDL基础-利用AIDL实现客户端向服务端传递基本类型
最新发布
05-02
在Android开发中，AIDL（Android Interface Definition Language）是一种用于跨进程通信（IPC，Inter-Process Communication）的机制，使得应用程序的不同组件可以在不同的进程中相互通信。本教程将深入讲解如何利用...
IPC机制---04 Android中的IPC通讯方式（C）
小洋人最happy的专栏
03-10 561
上一篇中，在服务端的BookService中使用的是ArrayList，这是一个线程不安全的集合，因为AIDL的方法是在Binder的线程池中执行的，因此当多个客户端同时连接的时候，会存在多个线程同时访问的情况，所以我们要在AIDL方法中处理线程同步，下面使用一个新的集合类来代替它--CopyOnWriteArrayList
Android IPC机制-AIDL详解
那时候的坚持不懈的我的博客
03-24 599
什么是AIDL? 官方解释:AIDL（Android 接口定义语言）与您可能使用过的其他 IDL 类似。 您可以利用它定义客户端与服务使用进程间通信 (IPC) 进行相互通信时都认可的编程接口。 在 Android 上，一个进程通常无法访问另一个进程的内存。 尽管如此，进程需要将其对象分解成操作系统能够识别的原语，并将对象编组成跨越边界的对象。 编写执行这一编组操作的代码是一项繁琐的工作，因此 An
IPC机制--利用Messenger
NoClay's Home
02-27 276
为什么使用Messenger？Messenger是一种轻量级的IPC方案，它的底层实现是AIDL，同时由于一次只是处理一个请求，那么我们就不需要考虑线程同步的问题。怎样实现一个Messenger？1. 服务端进程我们需要在服务端简历一个Service来处理客户端的连接请求，同时创建一个Handler，并通过它来创建一个Messenger对象，然后在Service的onBind中返回这个Messeng
IPC机制--概述
NoClay's Home
02-26 516
什么是IPC？IPC是Inter-Process Communication的缩写，含义是进程间通信，指的是不同进程之间进行数据交换的过程。一个进程可以包含许多的线程，但是可以只有一个主线程（在Android里边叫作UI线程）。如何开启多进程模式？名义上Android的多进程模式的开启只需要一行代码，但随之产生的许多问题却需要我们来进行考虑，比如进程间的数据的共享，内存共享等，如下为开启多进程模式代
IPC机制--BinderPool
NoClay's Home
03-02 377
当很多模块都需要AIDL来进行跨进程通信，我们不可能为每一个AIDL创建Sevice，因此，我们可以采用BinderPool来托管我们的其他进程间通信接口，通过一些请求码对不同的进程间通信接口加以区分，在进行指定的进程间通信的时候，先从BinderPool中取出对应的Binder，利用其进行通信即可。利用这个方法，避免了多次创建Service，以及对系统资源的滥用，我们来看下如何实现BinderPo
IPC机制---03 IPC基础概念介绍
小洋人最happy的专栏
01-26 984
IPC基础概念包括三部分：Serializable Parcelable和Binder。前两者为序列号和反序列化接口，可以完成对象的序列化，通过Intent或Binder进行对象数据传递时，或将对象持久到设备上或通过网络传输给其他客户端时，需要实现这两个接口中的一个。
Android IPC机制详解--Binder
hipeboy的博客
09-17 482
最近在学习贯穿android 系统的binder，今天就分享下这几天的学习心得： 本文主要从以下几个方面来介绍IPC机制 1、什么是IPC 2、Binder机制原理 3、AIDL实现 一、什么是IPC IPC是Inter-Process-Communication的缩写，意思是进程间通信或者跨进程通信； 说起进程间通信，我们应该首先来了解一下什么是进程。按照操作系统的描述，线程是CPU调度的最小单元，而进程一般指一个执行单元，在移动设备上指一个程序或应用；一个进程可以包含多个线程； 为什么要用到多进程？ 在
android IPC通信（下）－AIDL
热门推荐
Shawn_Dut的专栏
12-17 2万+
android IPC通信（上）－sharedUserId&&Messenger 　　android IPC通信（中）－ContentProvider&&Socket 　　这篇我们将会着重介绍AIDL的使用方式和原理，要介绍AIDL先要简单介绍一下 Binder，而且 Messenger，ContentProvider 和 AIDL 的最底层都是使用的 Binder。 　　相关博客介绍：
Android IPC机制（2）-AIDL
weixin_33894640的博客
03-24 71
本系列的所有文章：Android IPC机制（1）-序列化机制Android IPC机制（2）-AIDLAndroid IPC机制（3）-MessengerAndroid IPC机制（4）-Binder连接池 一、概述 AIDL 意思即 Android Interface Definition Languag...
AIDL----Android进程间通信（IPC）代码
11-08
通过上述步骤，我们可以利用AIDL实现Android进程间的通信。在实际项目中，可以根据需求设计更复杂的接口，实现灵活的数据交换和组件交互。在测试代码`AIDLTest`中，你可以模拟上述过程，测试AIDL接口的正确性和效率...
IPC机制之AIDL
02-27
通过AIDL，我们可以创建出更加健壮、高效的应用，充分利用Android系统的资源。结合提供的AIDL_1.png思维导图和AIDL.xmind文件，你可以更直观地了解AIDL的工作流程和应用场景。在实践中不断探索，你将更加熟练地运用...
解决打开Android Device Monitor一系列问题
NoClay's Home
07-22 2万+
问题1：解决打开Android Device Monitor之后一片空白问题描述将手机升级到Android 7.0后，打开android Device Monitor(DDMS)后，File Explorer中显示一片空白。如下：Android Device Monitor （DDMS）的版本如下：不管用monitor.bat（注ddms.bat已弃用）还是通过Android Studio中的图标启
Android--ListView的数据错乱bug（adapter的优化）
NoClay's Home
08-07 6796
声明：本文为我在写一个点赞功能时候遇到的bug，借鉴了一篇博客，其中讲解了关于颜色错乱，头像错乱，checkbox错乱之类的东西，这里只是简单的从checkbox谈一下我对于这个adapter优化机制的理解。1.ListView的Adapteradapter的含义是适配器，是数据项与listView视图显示之间的桥梁 “An adapter manages the data model and
如何将zxing导入到Android Studio项目
NoClay's Home
08-08 5504
如何将zxing导入到Android Studio项目我们这里新建一个demo来示范导入的动作！首先这里我们所依赖的是一个zxing的项目：建立Module导入zxing1. 下载这个zxing项目源码这个项目中有一些文件是我们所需要的，所以我们进行下载后解压放到某个文件夹2. 创建一个新的module具体的创建方法是File > new > new Module > Android Library
Android--从Java线程到安卓线程
NoClay's Home
04-25 5130
写在前面：本文为安卓线程与JAVA线程的异同，请多多指正！ 简述：相信很多学安卓的都是从java入门之后开始进行安卓的学习，而当我们面临安卓线程的书写的时候，发现安卓线程并不是我们想象中使用java的线程写法就可以。java线程的语法移植出错了？ 这里我们简单的书写一个TextClock（由TextView 和Calendar组成），这里的Button用于终止时间。这里我们使用java上线程的写法来
RemoteView的使用
NoClay's Home
08-01 4657
版权说明文章原载于：天意博文本文在此基础上进行了部分修改。AppWidget想要完全的理解RetmoteViews必须要说明一下Android Widet。Android widget 也称为桌面插件，其是android系统应用开发层面的一部分。Android中的AppWidget与google widget和中移动的widget并不是一个概念，这里的AppWidget只是把一个进程的控件嵌入到别外
深入理解Android Binder IPC机制
"初识Binder，理解Android的IPC机制——Binder" 在Android系统中，Binder是实现进程间通信（IPC）的关键机制。由于Linux内核的特性，不同进程之间的资源和信息不能直接共享，这就需要一种机制来允许进程之间安全...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值