Object类型作为binder调用的参数--如何实现这种自定义类型

系统管理员 2022-05-17 08:05 107阅读 0赞

分析ActivityManagerService和应用进程的IApplicationThread的通信说明：

1.ActivityManagerService调用IApplicationThread客户端的bindApplication（）方法，其中IApplicationThread的定义如下：

void bindApplication(String packageName, ApplicationInfo info, List<ProviderInfo> providers,
                ComponentName testName, ProfilerInfo profilerInfo, Bundle testArguments,
                IInstrumentationWatcher testWatcher, IUiAutomationConnection uiAutomationConnection,
                int debugMode, boolean openGlTrace, boolean restrictedBackupMode, boolean persistent,
                Configuration config, CompatibilityInfo compatInfo, Map<String, IBinder> services,
                Bundle coreSettings) throws RemoteException;

然后就可以看看这些参数都是怎么实现，拿ProviderInfo举例分析：

package android.content.pm;
    
    import android.os.Parcel;
    import android.os.Parcelable;
    import android.os.PatternMatcher;
    import android.util.Printer;
    
    /**
     * Holds information about a specific
     * {@link android.content.ContentProvider content provider}. This is returned by
     * {@link android.content.pm.PackageManager#resolveContentProvider(java.lang.String, int)
     * PackageManager.resolveContentProvider()}.
     */
    public final class ProviderInfo extends ComponentInfo
            implements Parcelable {
        
        /** The name provider is published under content:// */
        public String authority = null;
        
        /** Optional permission required for read-only access this content
         * provider. */
        public String readPermission = null;
        
        /** Optional permission required for read/write access this content
         * provider. */
        public String writePermission = null;
        
        /** If true, additional permissions to specific Uris in this content
         * provider can be granted, as per the
         * {@link android.R.styleable#AndroidManifestProvider_grantUriPermissions
         * grantUriPermissions} attribute.
         */
        public boolean grantUriPermissions = false;
        
        /**
         * If non-null, these are the patterns that are allowed for granting URI
         * permissions.  Any URI that does not match one of these patterns will not
         * allowed to be granted.  If null, all URIs are allowed.  The
         * {@link PackageManager#GET_URI_PERMISSION_PATTERNS
         * PackageManager.GET_URI_PERMISSION_PATTERNS} flag must be specified for
         * this field to be filled in.
         */
        public PatternMatcher[] uriPermissionPatterns = null;
        
        /**
         * If non-null, these are path-specific permissions that are allowed for
         * accessing the provider.  Any permissions listed here will allow a
         * holding client to access the provider, and the provider will check
         * the URI it provides when making calls against the patterns here.
         */
        public PathPermission[] pathPermissions = null;
        
        /** If true, this content provider allows multiple instances of itself
         *  to run in different process.  If false, a single instances is always
         *  run in {@link #processName}. */
        public boolean multiprocess = false;
        
        /** Used to control initialization order of single-process providers
         *  running in the same process.  Higher goes first. */
        public int initOrder = 0;
    
        /**
         * Bit in {@link #flags}: If set, a single instance of the provider will
         * run for all users on the device.  Set from the
         * {@link android.R.attr#singleUser} attribute.
         */
        public static final int FLAG_SINGLE_USER = 0x40000000;
    
        /**
         * Options that have been set in the provider declaration in the
         * manifest.
         * These include: {@link #FLAG_SINGLE_USER}.
         */
        public int flags = 0;
    
        /**
         * Whether or not this provider is syncable.
         * @deprecated This flag is now being ignored. The current way to make a provider
         * syncable is to provide a SyncAdapter service for a given provider/account type. 
         */
        @Deprecated
        public boolean isSyncable = false;
    
        public ProviderInfo() {
        }
    
        public ProviderInfo(ProviderInfo orig) {
            super(orig);
            authority = orig.authority;
            readPermission = orig.readPermission;
            writePermission = orig.writePermission;
            grantUriPermissions = orig.grantUriPermissions;
            uriPermissionPatterns = orig.uriPermissionPatterns;
            pathPermissions = orig.pathPermissions;
            multiprocess = orig.multiprocess;
            initOrder = orig.initOrder;
            flags = orig.flags;
            isSyncable = orig.isSyncable;
        }
    
        public void dump(Printer pw, String prefix) {
            super.dumpFront(pw, prefix);
            pw.println(prefix + "authority=" + authority);
            pw.println(prefix + "flags=0x" + Integer.toHexString(flags));
        }
    
        public int describeContents() {
            return 0;
        }
    
        @Override public void writeToParcel(Parcel out, int parcelableFlags) {
            super.writeToParcel(out, parcelableFlags);
            out.writeString(authority);
            out.writeString(readPermission);
            out.writeString(writePermission);
            out.writeInt(grantUriPermissions ? 1 : 0);
            out.writeTypedArray(uriPermissionPatterns, parcelableFlags);
            out.writeTypedArray(pathPermissions, parcelableFlags);
            out.writeInt(multiprocess ? 1 : 0);
            out.writeInt(initOrder);
            out.writeInt(flags);
            out.writeInt(isSyncable ? 1 : 0);
        }
    
        public static final Parcelable.Creator<ProviderInfo> CREATOR
                = new Parcelable.Creator<ProviderInfo>() {
            public ProviderInfo createFromParcel(Parcel in) {
                return new ProviderInfo(in);
            }
    
            public ProviderInfo[] newArray(int size) {
                return new ProviderInfo[size];
            }
        };
    
        public String toString() {
            return "ContentProviderInfo{name=" + authority + " className=" + name + "}";
        }
    
        private ProviderInfo(Parcel in) {
            super(in);
            authority = in.readString();
            readPermission = in.readString();
            writePermission = in.readString();
            grantUriPermissions = in.readInt() != 0;
            uriPermissionPatterns = in.createTypedArray(PatternMatcher.CREATOR);
            pathPermissions = in.createTypedArray(PathPermission.CREATOR);
            multiprocess = in.readInt() != 0;
            initOrder = in.readInt();
            flags = in.readInt();
            isSyncable = in.readInt() != 0;
        }
    }

关键的实现：

1.实现parcelable接口，然后就去实现parcelable\#writeToParcel（）把一个对象扁平化，类似序列化，就是把对象拆分成String，基本类型和基本类型数组。。对象中的成员如果是对象的话，也要实现Parcelable，一路下去。看Parcel方法的解释，也可以实现Serializable，但是效率没有那么高。

2.必须要声明并定义名为CREATOR的parcelable.Creator对象，在通过Parcel\#readParcelable()时会使用这个CREATOR去restore这个对象。其中必须实现parcelable.Creator.createFromParcel();把接收到的基本类型和基本类型数组作为参数传入构造方法初始化一个实例。binder调用传参数就类似于一般调用中的值传递了。

3.createFromParcel（）会把parcel作为参数传入ProviderInfo的构造方法，构造方法利用从Parcel restore出来的基本类型数据构造一个实例

其实所有对象本来最基本的元素就是基本类型，对象只是封装而已。

Parcelable类就是服务于Parcel，专用于将实例写入Parcel，然后将该实例从Parcel restore。Parcel是在android.os包的，而Serializable是在java.io。就是说Parcelable其实是android为binder通信而设计的一个类似Serializable的类。

Interface for classes whose instances can be written to
     * and restored from a {@link Parcel}.  Classes implementing the Parcelable
     * interface must also have a non-null static field called <code>CREATOR</code>
     * of a type that implements the {@link Parcelable.Creator} interface.

把这种和AIDL结合起来，可以参考这篇博文：[https://blog.csdn.net/dongjun7357/article/details/52488165][https_blog.csdn.net_dongjun7357_article_details_52488165]

[https_blog.csdn.net_dongjun7357_article_details_52488165]: https://blog.csdn.net/dongjun7357/article/details/52488165