深海游弋的鱼 – 第 4 页

Android R（11）文件选择兼容

对于 Android R(11) 使用 ContentResolver 检索图片，音乐，视频文件，参考 Android R(11) ContentResolver报错java.lang.IllegalArgumentException: Invalid token limit 里面的代码即可实现。但是如果想上传 PDF，TXT等文件的时候，则会发现系统无任何数据返回。

下面探讨一下如何解决这个问题：

一.储存

首先，我们需要对Android的储存有所了解
Android储存器可分为内部储存和外部储存，这里的内部储存和外部储存不是说有两个物理储存器而是系统在硬盘上划分了两个专用目录用作内部储存和外部储存。简单来说，我们通过系统文件管理器看到的目录都属于外部储存，外部储存又可分为三类目录，私有目录、公共目录、其它目录，而内部储存对于用户是隐藏的，如数据库、SharedPreferences等文件都放在内部储存中。

内部储存

//内部储存的文件目录获取方法，打印路径：/data/user/0/{应用包名}/files
//
Context.getFilesDir()

//内部储存的缓存目录获取方法，打印路径：/data/user/0/{应用包名}/cache
Context.getCacheDir()

//内部储存的文件目录获取方法，打印路径：/data/user/0/{应用包名}/files

Context.getFilesDir()

//内部储存的缓存目录获取方法，打印路径：/data/user/0/{应用包名}/cache

Context.getCacheDir()

内部储存对应的目录为/data/user/0/{应用包名}，该目录下应用有权限进行文件操作，目录对外不可见，应用删除对应的目录也会被删除。

外部储存

1.私有目录

//私有目录的文件目录获取方法，打印路径：/storage/emulated/0/Android/data/{应用包名}/files
//方法参数可选，例如传入Environment.DIRECTORY_PICTURES拿到的目录为/storage/emulated/0/Android/data/com.example.android11/files/Pictures
Context.getExternalFilesDir(null)

//私有目录的缓存目录获取方法，打印路径：/storage/emulated/0/Android/data/{应用包名}/cache
Context.getExternalCacheDir()

//私有目录的文件目录获取方法，打印路径：/storage/emulated/0/Android/data/{应用包名}/files

//方法参数可选，例如传入Environment.DIRECTORY_PICTURES拿到的目录为/storage/emulated/0/Android/data/com.example.android11/files/Pictures

Context.getExternalFilesDir(null)

//私有目录的缓存目录获取方法，打印路径：/storage/emulated/0/Android/data/{应用包名}/cache

Context.getExternalCacheDir()

私有目录获取和内部储存获取方式类似，都有file和cache目录，且该目录下应用有权限进行文件操作，目录对外可见，应用删除对应的目录也会被删除。
从Android11开始，私有目录不能被外部访问，即使获取了“所有文件管理”权限也不行（当然也是有其它方式可以实现Data目录的访问，不过目前看来并不完美）

2.公共目录

Downloads、Documents、Pictures 、DCIM、Movies、Music、Ringtones等目录都是公共目录，Android11前可以通过文件路径直接访问，Android11后需要通过MediaStore来进行访问。

3.其它目录

外部储存中除了私有目录和公共目录外都是其它目录，Android11后不能直接对其它目录进行访问。

二.分区存储

Android10中已经加入了分区储存机制，不过是非强制的，适配Android10只需在AndroidManifest.xml中添加 android:requestLegacyExternalStorage="true"即可。而在Android11已经强制应用使用分区储存。

三.兼容方式

1.MANAGE_EXTERNAL_STORAGE（不推荐）

<!-- manifest中注册 -->
<uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE"
        tools:ignore="ScopedStorage" />

<uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE"

tools:ignore="ScopedStorage" />

开启授权页面

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && !Environment.isExternalStorageEmulated()) {
            val intent = Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION)
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
            startActivity(intent)
        }

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && !Environment.isExternalStorageEmulated()) {

val intent = Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION)

intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)

startActivity(intent)

}

获取“所有文件管理”的权限可以读写除私有目录外的所有文件，但是这种权限一般为文件管理类的软件才需要申请。一般APP申请此类权限若上架Google，华为等应用市场大概率被拒。

2.存储访问框架 (SAF)（推荐）

应用如果有做文件选择上传类的功能可以使用此方式，通过启动一个系统的文件浏览页面，选择需要的文件后返回一个uri，之后将uri转成流上传或者将通过uri复制文件到私有目录再操作复制后的文件进行上传，这里切记不能直接将uri转成File去进行操作。

//启动SAF文件选择
Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
intent.addCategory(Intent.CATEGORY_OPENABLE);
intent.setType(MimeTypeMap.getSingleton().getMimeTypeFromExtension("pdf"));//这里以打开PDF选择为例
startActivityForResult(intent, 10086);

//启动SAF文件选择

Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);

intent.addCategory(Intent.CATEGORY_OPENABLE);

intent.setType(MimeTypeMap.getSingleton().getMimeTypeFromExtension("pdf"));//这里以打开PDF选择为例

startActivityForResult(intent, 10086);

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == 10086 && resultCode == getActivity().RESULT_OK) {
                if (data.getData() != null) {
                  uriToFileApiQ(this, data.getData())
                }
        }
    }
    //将uri对应的文件复制一份到私有目录，之后就可以操作复制后的File了
    @RequiresApi(Build.VERSION_CODES.Q)
    public File uriToFileApiQ(Context context, Uri uri) {
        File file = null;
        if (uri == null) return file;
        //android10以上转换
        if (uri.getScheme().equals(ContentResolver.SCHEME_FILE)) {
            file = new File(uri.getPath());
        } else if (uri.getScheme().equals(ContentResolver.SCHEME_CONTENT)) {
            //把文件复制到沙盒目录
            ContentResolver contentResolver = context.getContentResolver();
            String displayName = "uritofile"
                    + "." + MimeTypeMap.getSingleton().getExtensionFromMimeType(contentResolver.getType(uri));
            InputStream is = null;
            try {
                is = contentResolver.openInputStream(uri);
                File cache = new File(context.getCacheDir().getAbsolutePath(), displayName);
                FileOutputStream fos = new FileOutputStream(cache);
                byte[] b = new byte[1024];
                while ((is.read(b)) != -1) {
                    fos.write(b);// 写入数据
                }
                file = cache;
                fos.close();
                is.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return file;
    }

@Override

public void onActivityResult(int requestCode, int resultCode, Intent data) {

if (requestCode == 10086 && resultCode == getActivity().RESULT_OK) {

if (data.getData() != null) {

uriToFileApiQ(this, data.getData())

}

//将uri对应的文件复制一份到私有目录，之后就可以操作复制后的File了

@RequiresApi(Build.VERSION_CODES.Q)

public File uriToFileApiQ(Context context, Uri uri) {

File file = null;

if (uri == null) return file;

//android10以上转换

if (uri.getScheme().equals(ContentResolver.SCHEME_FILE)) {

file = new File(uri.getPath());

} else if (uri.getScheme().equals(ContentResolver.SCHEME_CONTENT)) {

//把文件复制到沙盒目录

ContentResolver contentResolver = context.getContentResolver();

String displayName = "uritofile"

+ "." + MimeTypeMap.getSingleton().getExtensionFromMimeType(contentResolver.getType(uri));

InputStream is = null;

try {

is = contentResolver.openInputStream(uri);

File cache = new File(context.getCacheDir().getAbsolutePath(), displayName);

FileOutputStream fos = new FileOutputStream(cache);

byte[] b = new byte[1024];

while ((is.read(b)) != -1) {

fos.write(b);// 写入数据

}

file = cache;

fos.close();

is.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

return file;

}

参考链接

Android:加载PDF几种方法汇总对比

在安卓项目中，加载PDF文件，是一个比较常见的需求。又分为两大类，

1.加载网络PDF

2.加载一个本地静态PDF。

查阅资料，纵观网上在安卓中打开PDF的各种方式，大致可以分为以下几类，

1.直接使用第三方软件打开(包括浏览器打开和第三方软件打开)

如果是在app内部加载PDF文件，虽然安卓原生API对于PDF的支持又不是太好，但是各种第三方专门的阅读或者办公软件支持的是很不错的，可以通过Intent配置data和type实现。

其中，在实际需求中又会分为加载本地PDF和网络PDF的情况。

使用浏览器打开PDF：（APP外部打开，适用于加载网络PDF）

public static void openPDFInBrowser(Context context, String url) {
        Uri uri = Uri.parse(url);
        Intent intent = new Intent(Intent.ACTION_VIEW, uri);
        intent.putExtra(Browser.EXTRA_APPLICATION_ID, context.getPackageName());
        try {
            context.startActivity(intent);
        } catch (ActivityNotFoundException e) {
            Log.w("error", "Activity was not found for intent, " + intent.toString());
        }
    }

public static void openPDFInBrowser(Context context, String url) {

Uri uri = Uri.parse(url);

Intent intent = new Intent(Intent.ACTION_VIEW, uri);

intent.putExtra(Browser.EXTRA_APPLICATION_ID, context.getPackageName());

try {

context.startActivity(intent);

} catch (ActivityNotFoundException e) {

Log.w("error", "Activity was not found for intent, " + intent.toString());

}

使用手机上已安装的可以打开PDF的第三方软件来打开PDF：（APP外部打开，适用于加载本地PDF）

（使用这种方式缺点是：手机上如果一个可以打开PDF的软件，那么就尴尬了~）

 public static void openPDFInNative(Context context, String FILE_NAME) {
        File file = new File(context.getExternalCacheDir(),FILE_NAME);
        Intent intent = new Intent(Intent.ACTION_VIEW);
        Uri uri = Uri.fromFile(file);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.setDataAndType(uri, "application/pdf");
        try {
            context.startActivity(intent);
        } catch (ActivityNotFoundException e) {
            Log.w("URLSpan", "Activity was not found for intent, " + intent.toString());
        }
    }

public static void openPDFInNative(Context context, String FILE_NAME) {

File file = new File(context.getExternalCacheDir(),FILE_NAME);

Intent intent = new Intent(Intent.ACTION_VIEW);

Uri uri = Uri.fromFile(file);

intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

intent.setDataAndType(uri, "application/pdf");

try {

context.startActivity(intent);

} catch (ActivityNotFoundException e) {

Log.w("URLSpan", "Activity was not found for intent, " + intent.toString());

}

2.连接Google服务器解析

安卓的WebView不支持PDF解析，因此通过连接Google的一个服务器转换成功后返回给WebView显示。但是，但是，但是呢，大家都懂的，天朝和Google之间有一道高高的墙。方法还是贴出来，作为国际化APP的一种方案。

mWebView.loadUrl("http://docs.google.com/gview?embedded=true&url="+ pdfUrl);

1	mWebView.loadUrl("http://docs.google.com/gview?embedded=true&url="+ pdfUrl);

3.用第三方库加载

Github上有一个Java开源项目 https://github.com/barteksc/AndroidPdfViewer ,
这个库的大致原理，是内置了一个PDF解析器，以流的方式将网络PDF从网上Down下来，然后再以流的方式将其还原成PDF展示出来（具体细节没关注）。亲测中，这个库每次进入webview页面都会解析加载一遍PDF，如果PDF过大，费时无缓存不说，最致命的问题乃是，

APK包体积会瞬间增大15M左右，

具体原因不明，估计应该是内置PDF解析器的问题。于是，此方法被我抛弃了。

4.使用Moliza开源的Pdf.js

这个JS类库也是很强大的,配合原生的WebView使用,支持预览,缩放,翻页的功能,实现效果和WKWebView没差。同样也有体积问题,全部放到本地apk的话包大小差不多会增加5M左右。但相比上一种方式还是轻量一些：
http://www.jb51.net/article/136364.htm

5.使用安卓自带的PdfRenderer类加载

如果要求支持的功能不是很多,用安卓提供的PdfRender就可以满足需求了。PdfRender加载多页的话可以配合ViewPager或者RecyclerView使用。需要注意的是使用PdfRender需要先将PDF文件下载到本地，是线程不安全的，并且API>=21才能使用。因为这种方式是将PDF下载到本地，于是就产生了新问题：占内存。如果是静态的PDF文件不大还好，但是如果是频繁加载网络PDF的需求，那就头疼了，这种方式需要做好定时清理删除PDF的工作，否则，GG。

这里提供的示例是阿里巴巴Android开发手册,放到assets目录下.

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public class MainActivity extends AppCompatActivity {

    private ViewPager vpPdf;

    private LayoutInflater mInflater;
    private ParcelFileDescriptor mDescriptor;
    private PdfRenderer          mRenderer;

    public static final String FILE_NAME = "alibaba.pdf";

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

        mInflater = LayoutInflater.from(this);
        vpPdf =findViewById(R.id.vp_pdf);

        try {
            openRender();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    private void openRender() throws IOException {

        File file = new File(getExternalCacheDir(), FILE_NAME);
        if (!file.exists()) {
            //复制文件到本地存储
            InputStream asset = getAssets().open(FILE_NAME);
            FileOutputStream fos = new FileOutputStream(file);
            byte[] buffer = new byte[1024];

            int size;
            while ((size = asset.read(buffer)) != -1) {
                fos.write(buffer, 0, size);
            }

            asset.close();
            fos.close();
        }

        //初始化PdfRender
        mDescriptor = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
        if (mDescriptor != null) {
            mRenderer = new PdfRenderer(mDescriptor);
        }

        //初始化ViewPager的适配器并绑定
        MyAdapter adapter = new MyAdapter();
        vpPdf.setAdapter(adapter);
    }

    @Override
    protected void onDestroy() {
        //销毁页面的时候释放资源,习惯
        try {
            closeRenderer();
        } catch (IOException e) {
            e.printStackTrace();
        }
        super.onDestroy();
    }

    private void closeRenderer() throws IOException{
        mRenderer.close();
        mDescriptor.close();

    }

    class MyAdapter extends PagerAdapter{

        @Override
        public int getCount() {
            return mRenderer.getPageCount();
        }

        @Override
        public boolean isViewFromObject(View view, Object object) {
            return view==object;
        }

        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            View view = mInflater.inflate(R.layout.item_pdf, null);

            PhotoView pvPdf = view.findViewById(R.id.iv_pdf);
            pvPdf.enable();

            if (getCount() <= position) {
                return view;
            }

            PdfRenderer.Page currentPage = mRenderer.openPage(position);
            Bitmap bitmap = Bitmap.createBitmap(1080, 1760, Bitmap.Config
                    .ARGB_8888);
            currentPage.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY);
            pvPdf.setImageBitmap(bitmap);
            //关闭当前Page对象
            currentPage.close();

            container.addView(view);
            return view;
        }

        @Override
        public void destroyItem(ViewGroup container, int position, Object object) {
            //销毁需要销毁的视图
            container.removeView((View) object);
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

@TargetApi(Build.VERSION_CODES.LOLLIPOP)

public class MainActivity extends AppCompatActivity {

private ViewPager vpPdf;

private LayoutInflater mInflater;

private ParcelFileDescriptor mDescriptor;

private PdfRenderer mRenderer;

public static final String FILE_NAME = "alibaba.pdf";

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

mInflater = LayoutInflater.from(this);

vpPdf =findViewById(R.id.vp_pdf);

try {

openRender();

} catch (IOException e) {

e.printStackTrace();

}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)

private void openRender() throws IOException {

File file = new File(getExternalCacheDir(), FILE_NAME);

if (!file.exists()) {

//复制文件到本地存储

InputStream asset = getAssets().open(FILE_NAME);

FileOutputStream fos = new FileOutputStream(file);

byte[] buffer = new byte[1024];

int size;

while ((size = asset.read(buffer)) != -1) {

fos.write(buffer, 0, size);

}

asset.close();

fos.close();

}

//初始化PdfRender

mDescriptor = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);

if (mDescriptor != null) {

mRenderer = new PdfRenderer(mDescriptor);

}

//初始化ViewPager的适配器并绑定

MyAdapter adapter = new MyAdapter();

vpPdf.setAdapter(adapter);

}

@Override

protected void onDestroy() {

//销毁页面的时候释放资源,习惯

try {

closeRenderer();

} catch (IOException e) {

e.printStackTrace();

}

super.onDestroy();

}

private void closeRenderer() throws IOException{

mRenderer.close();

mDescriptor.close();

}

class MyAdapter extends PagerAdapter{

@Override

public int getCount() {

return mRenderer.getPageCount();

}

@Override

public boolean isViewFromObject(View view, Object object) {

return view==object;

}

@Override

public Object instantiateItem(ViewGroup container, int position) {

View view = mInflater.inflate(R.layout.item_pdf, null);

PhotoView pvPdf = view.findViewById(R.id.iv_pdf);

pvPdf.enable();

if (getCount() <= position) {

return view;

}

PdfRenderer.Page currentPage = mRenderer.openPage(position);

Bitmap bitmap = Bitmap.createBitmap(1080, 1760, Bitmap.Config

.ARGB_8888);

currentPage.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY);

pvPdf.setImageBitmap(bitmap);

//关闭当前Page对象

currentPage.close();

container.addView(view);

return view;

}

@Override

public void destroyItem(ViewGroup container, int position, Object object) {

//销毁需要销毁的视图

container.removeView((View) object);

}

PdfRender的大致调用方式是:

初始化PdfRender,将PDF文件转换为ParcelFileDescriptor作为入参
通过getPageCount()获得Pdf的总页数
循环遍历,通过openPage()获得一个封装了当前页Pdf参数的内部类Page
创建一个Bitmap对象,,用上步获取的Page加载,相当于把当前Pdf页的内容渲染到了Bitmap上
对Bitmap进行你想要的操作,每次循环结束后关闭当前Page。

大部分都是常规操作，但要注意两点:

1. 每次循环创建的Page对象在使用完毕后必须调用close()。否则其内部的openPage()判断会抛异常；

2.Bitmap占用内存较大，如果用ViewPager加载一定要重写Adapter中的destroyItem()，及时的将需要销毁的视图从父容器中移除,否则快速滑动几页后会OOM。

参考链接

android:加载PDF几种方法汇总对比

如何让Android Studio/IntelliJ IDEA不对自定义的NULL检查方法发出警告

在平时的开发过程中，我们一般会自定义函数对变量是否为 null 进行检查，当检查函数返回成功的时候，对象一定不是 null 。

但是，这个自定义的函数，对于 Android Studio/IntelliJ IDEA 来说，是无法感知到的，导致 Android Studio/IntelliJ IDEA 会发出警告，没有对变量是否为 null 进行检查。

出现上述问题的例子如下：

import java.util.Random;

public class Test {

    // validator method
    static boolean hasText(String s) {
        return !(s == null || s.trim().isEmpty());
    }

    public static void main(String[] args) {
        // s could come from anywhere and is null iff the data does not exist
        String s = (new Random().nextBoolean()) ? "valid" : null;
        if (hasText(s)) {
            // Potential null pointer access: The variable s may be null at this location
            System.out.println(s.length());
            // ... do actual stuff ...
        }
    }
}

import java.util.Random;

public class Test {

// validator method

static boolean hasText(String s) {

return !(s == null || s.trim().isEmpty());

}

public static void main(String[] args) {

// s could come from anywhere and is null iff the data does not exist

String s = (new Random().nextBoolean()) ? "valid" : null;

if (hasText(s)) {

// Potential null pointer access: The variable s may be null at this location

System.out.println(s.length());

// ... do actual stuff ...

}

那么，有没有办法告知 Android Studio/IntelliJ IDEA ，我们已经对 null 进行过检查了呢？

网上搜索许久，尝试过 @CheckForNull / @EnsuresNonNullIf 注解，都不能解决问题。

最终发现使用 jetbrains 的 @Contract 注解能解决此问题。

上述的例子增加以下注解，明确告知编译器，如果参数是 null 函数一定返回 false，就可以阻止编译器发出警告了。

如下：

import java.util.Random;
import org.jetbrains.annotations.Contract;

public class Test {

    // validator method
    @Contract("null -> false")
    static boolean hasText(String s) {
        return !(s == null || s.trim().isEmpty());
    }

    public static void main(String[] args) {
        // s could come from anywhere and is null iff the data does not exist
        String s = (new Random().nextBoolean()) ? "valid" : null;
        if (hasText(s)) {
            // Potential null pointer access: The variable s may be null at this location
            System.out.println(s.length());
            // ... do actual stuff ...
        }
    }
}

import java.util.Random;

import org.jetbrains.annotations.Contract;

public class Test {

// validator method

@Contract("null -> false")

static boolean hasText(String s) {

return !(s == null || s.trim().isEmpty());

}

public static void main(String[] args) {

// s could come from anywhere and is null iff the data does not exist

String s = (new Random().nextBoolean()) ? "valid" : null;

if (hasText(s)) {

// Potential null pointer access: The variable s may be null at this location

System.out.println(s.length());

// ... do actual stuff ...

}

参考链接

Android各大市场更改APP名称

公司上架了一款App，因为产品运营需要去修改App名称，在iOS应用市场提交新版本的时候可以改App名称。那么Android 各大市场如何更改APP名称呢？

目前上架的Android 应用市场有：360手机助手、腾讯应用宝、百度手机助手、阿里应用分发市场（豌豆荚）、安智市场、小米应用商店、华为应用市场、OPPO商店、魅族应用商店、vivo应用市场、搜狗手机助手等平台。

每家Android应用市场的规则都不同，小编整理了Android 各大市场更改APP名称的规则。

1、百度 : 百度平台的最简单。直接更新app的版本即可(应用名称是系统从您提交的应用中解析的，如需修改请联系贵司技术修改apk包内信息。)

2、应用宝: 用上线后，开发者可通过工单系统提交应用名称修改需求（入口1：如图点击“名称更改指引”即可直接跳转到修改应用名称的工单系统；入口2：管理中心-->点击需要修改名称的应用-->基础服务-->工单系统-->应用宝商务类-->移动应用名称修改-->填单提交）。修改应用名称需要提供软件著作权；若暂无软著，可提供此款应用在其他外市场，改过名字后的前后台上线管理截图（其他证明文件均不接受）；

重要提示：根据平台规则，应用上线后，应用名称最多可支持修改2次，超过修改次数将不再受理，请谨慎确定好需要修改的应用名称后，再提交工单申请。

3、华为: 在开发者后台在该应用下点击上架或者升级，上传更名后的APK包，并在应用信息处更改应用名称，如应用分类涉及软著要求，请在“版本信息”的“应用版权证书或代理证书”处更新应用软著及免责函，提交应用审核。

4、360移动开放平台和百度移动开放平台是一样的，直接更新app的版本即可。

5、 vivo开放平台:

1)应用类APP需要修改名称：直接在后台编辑更新，保证apk包内和在后台填写的名称一致即可；若名称相差较大，请在版权证明栏补充软著；游戏类APP（网游/单机）需要修改名称：需联系对接商务处理。

2)若需要更改应用包名，请联系贵司技术人员；更改之后再在平台创建应用提交新包名应用，旧包名应用需申请下架（登录平台--管理中心--点击您的应用--“下架申请”即可）。

6、 OPPO开放平台：也是上传后将自动解析包名。

7、魅族开放平台：也是上传后将自动解析包名。

8、小米市场: 应用名称修改需于应用包内及应用信息一同更改。应用包内名称更改还请贵司技术开发人员自行更改。（可以试一下直接上传后将自动解析包名。）

9、豌豆荚（阿里云应用分发平台）：也是上传后将自动解析包名。

参考链接

Android 各大市场更改APP名称

编译NanoPi R5S Android 12 (RK3568)

最近，入手了一部 NanoPi R5S ，官方是提供了 Anroid 12 的系统镜像，~~但是却没有给出相应的源代码~~（2023年10月12日，NanoPi 官方已经给出了Android 12的源代码，整个共享目录大约130GB左右，建议直接使用官方源代码进行编译）。尝试用官方提供的 Anroid 11 编译，结果编译出的系统镜像无法正常运行。

凑巧看到研华科技放出了 RSB-4810 开发板的 Anroid 12 编译指南，两者的配置差不多，试了一下，竟然可以正常运行！！

系统要求，内存不低于 32GB，否则编译过程中可能会由于内存不足，造成编译失败。

研华科技官方文档是通过 docker 利用 ubuntu 18.04 进行编译的，如下：

1. 配置 docker 运行环境

$ sudo apt-get install docker

$ sudo docker pull advrisc/u18.04-rk3399abv10:latest;

# 注意，创建的目录必须是home的子目录，否则会在挂载的时候报错
# docker: Error response from daemon: error while creating mount source path '/data/r5s': mkdir /data: read-only file system.

$ mkdir r5s

$ sudo docker run --privileged -it --name android_S12 -v ~/r5s:/home/adv/BSP:rw advrisc/u18.04-rk3399abv10 /bin/bash

$ sudo chown adv:adv -R BSP

$ sudo apt-get install docker

$ sudo docker pull advrisc/u18.04-rk3399abv10:latest;

# 注意，创建的目录必须是home的子目录，否则会在挂载的时候报错

# docker: Error response from daemon: error while creating mount source path '/data/r5s': mkdir /data: read-only file system.

$ mkdir r5s

$ sudo docker run --privileged -it --name android_S12 -v ~/r5s:/home/adv/BSP:rw advrisc/u18.04-rk3399abv10 /bin/bash

$ sudo chown adv:adv -R BSP

2. 下载源代码并进行编译

$ cd ~/BSP

$ git clone https://github.com/ADVANTECH-Rockchip/repo.git

$ mkdir rk3568_android_S12

$ cd rk3568_android_S12

$ git config --global user.name 'Your Name'

$ git config --global user.email you@example.com

$ git config --global http.postBuffer 52428800000

$ git config --global http.maxRequestBuffer 100M

$ git config --global core.compression 0

$ ../repo/repo init -u https://dev.azure.com/AIM-Linux/RISC-RK3568-Android/_git/android-manifest -b rk3568-androidS12 -m RK3568_S12_AIV0001.xml

$ ../repo/repo sync -c -f --no-clone-bundle -j16

$ cd ~/BSP

$ git clone https://github.com/ADVANTECH-Rockchip/repo.git

$ mkdir rk3568_android_S12

$ cd rk3568_android_S12

$ git config --global user.name 'Your Name'

$ git config --global user.email you@example.com

$ git config --global http.postBuffer 52428800000

$ git config --global http.maxRequestBuffer 100M

$ git config --global core.compression 0

$ ../repo/repo init -u https://dev.azure.com/AIM-Linux/RISC-RK3568-Android/_git/android-manifest -b rk3568-androidS12 -m RK3568_S12_AIV0001.xml

$ ../repo/repo sync -c -f --no-clone-bundle -j16

3. 下载并解压缩编译工具（ prebuilts.tar.gz 密码: 1234）

Exit docker and copy the file to /home/your-name/myandroid
$ cp prebuilts.tar.gz ~/r5s/rk3568_android_S12/android

In container and Unzip file
$ docker attach android_S12

$ tar zxvf ~/BSP/rk3568_android_S12/android/prebuilts.tar.gz

Exit docker and copy the file to /home/your-name/myandroid

$ cp prebuilts.tar.gz ~/r5s/rk3568_android_S12/android

In container and Unzip file

$ docker attach android_S12

$ tar zxvf ~/BSP/rk3568_android_S12/android/prebuilts.tar.gz

4. 编译代码

$ source build/envsetup.sh;lunch rsb4810_s-userdebug;

$./build.sh -AUCKu

$ source build/envsetup.sh;lunch rsb4810_s-userdebug;

$./build.sh -AUCKu

5. 核对编译后的文件

编译完成后的产物在 rockdev/Image-rsb4810_s/ 目录下，具体的文件列表如下：

MiniLoaderAll.bin
baseparameter.img
boot-debug.img
boot.img
config.cfg
dtbo.img
misc.img
parameter.txt
pcba_small_misc.img
pcba_whole_misc.img
recovery.img
resource.img
super.img
uboot.img
update.img
vbmeta.img

MiniLoaderAll.bin

baseparameter.img

boot-debug.img

boot.img

config.cfg

dtbo.img

misc.img

parameter.txt

pcba_small_misc.img

pcba_whole_misc.img

recovery.img

resource.img

super.img

uboot.img

update.img

vbmeta.img

5. 刷机

按照正常的流程刷机，整个流程走起来会比较繁琐，此处给相对简单的做法。

1. 到NanoPi R5S官方WIKI 去下载已经编译好的镜像
2. 如果是需要SD卡刷机，则直接把下载到的镜像文件写入准备好的数据卡
3. 用刚刚编译出的文件替换SD卡上的android12目录下的同名文件，注意，只替换同名文件，里面的配置文件不要删除
4. 插上SD卡，重启即可完成刷机
5. 如果使用USB刷机，则也可以通过替换文件的方式达到相同的目的

参考链接

Robolectric 4.8.2修改进程名/私有静态变量

Roboletric 4.8.2 修改进程名:

import org.robolectric.shadows.ShadowApplication;

ShadowApplication.setProcessName();

import org.robolectric.shadows.ShadowApplication;

ShadowApplication.setProcessName();

Roboletric 4.8.2 修改私有静态变量：

import org.robolectric.util.ReflectionHelpers;

ReflectionHelpers.setStaticField(xx.class, "static filed name", value);

import org.robolectric.util.ReflectionHelpers;

ReflectionHelpers.setStaticField(xx.class, "static filed name", value);

如果报错：

java.lang.IllegalStateException: No instrumentation registered! Must run under a registering instrumentation.

	at androidx.test.platform.app.InstrumentationRegistry.getInstrumentation(InstrumentationRegistry.java:45)
	at androidx.test.core.app.ApplicationProvider.getApplicationContext(ApplicationProvider.java:41)

java.lang.IllegalStateException: No instrumentation registered! Must run under a registering instrumentation.

at androidx.test.platform.app.InstrumentationRegistry.getInstrumentation(InstrumentationRegistry.java:45)

at androidx.test.core.app.ApplicationProvider.getApplicationContext(ApplicationProvider.java:41)

则修改方式如下：

@PowerMockIgnore({"org.mockito.*", "org.robolectric.*", "android.*", "androidx.*"})

1	@PowerMockIgnore({"org.mockito.", "org.robolectric.", "android.", "androidx."})

完整的例子如下：

    import org.junit.runner.RunWith;
    import org.powermock.core.classloader.annotations.PowerMockIgnore;
    import org.powermock.modules.junit4.PowerMockRunner;
    import org.powermock.modules.junit4.PowerMockRunnerDelegate;
    import org.robolectric.RobolectricTestRunner;
    import org.robolectric.annotation.Config;
    
    
    /**
     * Base class extended by every Robolectric test in this project.
     * <p/>
     * You can use Powermock together with Robolectric.
     */
    @RunWith(PowerMockRunner.class)
    @PowerMockRunnerDelegate(RobolectricTestRunner.class)
    @Config(constants = BuildConfig.class,
            sdk = 21)
    @PowerMockIgnore({"org.mockito.*", "org.robolectric.*", "android.*", "androidx.*"})
    public abstract class RobolectricTest {
    
    }

import org.junit.runner.RunWith;

import org.powermock.core.classloader.annotations.PowerMockIgnore;

import org.powermock.modules.junit4.PowerMockRunner;

import org.powermock.modules.junit4.PowerMockRunnerDelegate;

import org.robolectric.RobolectricTestRunner;

import org.robolectric.annotation.Config;

/**

* Base class extended by every Robolectric test in this project.

* <p/>

* You can use Powermock together with Robolectric.

@RunWith(PowerMockRunner.class)

@PowerMockRunnerDelegate(RobolectricTestRunner.class)

@Config(constants = BuildConfig.class,

sdk = 21)

@PowerMockIgnore({"org.mockito.*", "org.robolectric.*", "android.*", "androidx.*"})

public abstract class RobolectricTest {

}

参考链接

Using PowerMock - robolectric/robolectric Wiki

Android Studio升级ArcticFox后单元测试报错“Test events were not received”

Android Studio升级ArcticFox后单元测试报错“Test events were not received”，如下图：

解决方法：目前最简单的方法就是升级到 Android Studio Chipmunk|2021.2.1 Path 2，然后对项目整体执行一次Clean，删除之前的测试用例并重建。

操作步骤如下图：

1. 清理工程代码，移除缓存

2. 选中出问题的测试用例的编辑配置

3. 移除之前的测试用例，这样可以迫使测试用例重建

4. 再次执行测试用例

参考链接

Android获取当前进程的名称

通过 ActivityManager 获取进程名

public static String getCurrentProcessNameByActivityManager(@NonNull Context context) {
  final int pid = Process.myPid();
  final ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
  if (null != am) {
    final List<ActivityManager.RunningAppProcessInfo> runningAppList = am.getRunningAppProcesses();
    if (null != runningAppList) {
      for (ActivityManager.RunningAppProcessInfo processInfo : runningAppList) {
        if (processInfo.pid == pid) {
          return processInfo.processName;
        }
      }
    }
  }
  return null;
}

public static String getCurrentProcessNameByActivityManager(@NonNull Context context) {

final int pid = Process.myPid();

final ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

if (null != am) {

final List<ActivityManager.RunningAppProcessInfo> runningAppList = am.getRunningAppProcesses();

if (null != runningAppList) {

for (ActivityManager.RunningAppProcessInfo processInfo : runningAppList) {

if (processInfo.pid == pid) {

return processInfo.processName;

}

return null;

}

缺点：

am.getRunningAppProcesses()需要跨进程通信，效率不高

ActivityManager.getRunningAppProcesses() 有可能调用失败，虽然概率不高但是当用户数量达到一定级别还是有概率失败的

Application.getProcessName() 只能Api28 以上的系统调用

最优解：

import android.annotation.SuppressLint;
import android.app.ActivityManager;
import android.app.Application;
import android.content.Context;
import android.os.Build;
import android.text.TextUtils;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import java.lang.reflect.Method;
import java.util.List;

public class ProcessHelper {

    /**
     * 当前进程名
     */
    private static String currentProcessName;

    /**
     * @return 当前进程名
     */
    @Nullable
    public static String getCurrentProcessName(@NonNull Context context) {
        if (TextUtils.isEmpty(currentProcessName)) {
            synchronized (ProcessHelper.class) {
                if (TextUtils.isEmpty(currentProcessName)) {
                    //1)通过Application的API获取当前进程名
                    currentProcessName = getCurrentProcessNameByApplication();
                    if (TextUtils.isEmpty(currentProcessName)) {
                        //2)通过反射ActivityThread获取当前进程名
                        currentProcessName = getCurrentProcessNameByActivityThread();
                        if (TextUtils.isEmpty(currentProcessName)) {
                            //3)通过ActivityManager获取当前进程名
                            currentProcessName = getCurrentProcessNameByActivityManager(context);
                        }
                    }
                }
            }
        }
        return currentProcessName;
    }


    /**
     * 通过Application新的API获取进程名，无需反射，无需IPC，效率最高。
     */
    private static String getCurrentProcessNameByApplication() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            return Application.getProcessName();
        }
        return null;
    }

    /**
     * 通过反射ActivityThread获取进程名，避免了ipc
     */
    private static String getCurrentProcessNameByActivityThread() {
        String processName = null;
        try {
            @SuppressLint("PrivateApi") final Class<?> clz = Class.forName("android.app.ActivityThread", false, Application.class.getClassLoader());
            @SuppressLint("DiscouragedPrivateApi") final Method m = clz.getDeclaredMethod("currentProcessName");
            m.setAccessible(true);
            final Object name = m.invoke(null);
            if (name instanceof String) {
                processName = (String) name;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return processName;
    }

    /**
     * 通过ActivityManager 获取进程名，需要IPC通信
     */
    private static String getCurrentProcessNameByActivityManager(@NonNull Context context) {
        final int pid = android.os.Process.myPid();
        final ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        if (null != am) {
            final List<ActivityManager.RunningAppProcessInfo> runningAppList = am.getRunningAppProcesses();
            if (null != runningAppList) {
                for (ActivityManager.RunningAppProcessInfo processInfo : runningAppList) {
                    if (processInfo.pid == pid) {
                        return processInfo.processName;
                    }
                }
            }
        }
        return null;
    }
}

import android.annotation.SuppressLint;

import android.app.ActivityManager;

import android.app.Application;

import android.content.Context;

import android.os.Build;

import android.text.TextUtils;

import androidx.annotation.NonNull;

import androidx.annotation.Nullable;

import java.lang.reflect.Method;

import java.util.List;

public class ProcessHelper {

/**

* 当前进程名

private static String currentProcessName;

/**

* @return 当前进程名

@Nullable

public static String getCurrentProcessName(@NonNull Context context) {

if (TextUtils.isEmpty(currentProcessName)) {

synchronized (ProcessHelper.class) {

if (TextUtils.isEmpty(currentProcessName)) {

//1)通过Application的API获取当前进程名

currentProcessName = getCurrentProcessNameByApplication();

if (TextUtils.isEmpty(currentProcessName)) {

//2)通过反射ActivityThread获取当前进程名

currentProcessName = getCurrentProcessNameByActivityThread();

if (TextUtils.isEmpty(currentProcessName)) {

//3)通过ActivityManager获取当前进程名

currentProcessName = getCurrentProcessNameByActivityManager(context);

}

return currentProcessName;

}

/**

* 通过Application新的API获取进程名，无需反射，无需IPC，效率最高。

private static String getCurrentProcessNameByApplication() {

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {

return Application.getProcessName();

}

return null;

}

/**

* 通过反射ActivityThread获取进程名，避免了ipc

private static String getCurrentProcessNameByActivityThread() {

String processName = null;

try {

@SuppressLint("PrivateApi") final Class<?> clz = Class.forName("android.app.ActivityThread", false, Application.class.getClassLoader());

@SuppressLint("DiscouragedPrivateApi") final Method m = clz.getDeclaredMethod("currentProcessName");

m.setAccessible(true);

final Object name = m.invoke(null);

if (name instanceof String) {

processName = (String) name;

}

} catch (Throwable e) {

e.printStackTrace();

}

return processName;

}

/**

* 通过ActivityManager 获取进程名，需要IPC通信

private static String getCurrentProcessNameByActivityManager(@NonNull Context context) {

final int pid = android.os.Process.myPid();

final ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

if (null != am) {

final List<ActivityManager.RunningAppProcessInfo> runningAppList = am.getRunningAppProcesses();

if (null != runningAppList) {

for (ActivityManager.RunningAppProcessInfo processInfo : runningAppList) {

if (processInfo.pid == pid) {

return processInfo.processName;

}

return null;

}

参考链接

android 获取当前进程的名称

Collections.singletonList/Collections.emptyList/Collections.emptyMap

最近在研究 Flutter 的 pigeon 例子 的时候，发现如下实例代码：

import dev.flutter.pigeon.Pigeon.*;
import java.util.Collections;

public class StartActivity extends Activity {
  private class MyApi implements BookApi {
    List<Book> search(String keyword) {
      Book result = new Book();
      result.author = keyword;
      result.title = String.format("%s's Life", keyword);
      return Collections.singletonList(result)
    }
  }

  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    BookApi.setup(getBinaryMessenger(), new MyApi());
  }
}

import dev.flutter.pigeon.Pigeon.*;

import java.util.Collections;

public class StartActivity extends Activity {

private class MyApi implements BookApi {

List<Book> search(String keyword) {

Book result = new Book();

result.author = keyword;

result.title = String.format("%s's Life", keyword);

return Collections.singletonList(result)

}

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

BookApi.setup(getBinaryMessenger(), new MyApi());

}

对其中的 Collections.singletonList(result) 比较感兴趣，研究了一下，发现还是比较有意义的。

Collections.singletonList()

这个方法主要用于只有一个元素的优化，减少内存分配，无需分配额外的内存，可以从SingletonList内部类看得出来,由于只有一个element,因此可以做到内存分配最小化，相比之下ArrayList的DEFAULT_CAPACITY=10个。

    /**
     * Returns an immutable list containing only the specified object.
     * The returned list is serializable.
     *
     * @param  <T> the class of the objects in the list
     * @param o the sole object to be stored in the returned list.
     * @return an immutable list containing only the specified object.
     * @since 1.3
     */
    public static <T> List<T> singletonList(T o) {
        return new SingletonList<>(o);
    }

/**

* Returns an immutable list containing only the specified object.

* The returned list is serializable.

* @param <T> the class of the objects in the list

* @param o the sole object to be stored in the returned list.

* @return an immutable list containing only the specified object.

* @since 1.3

public static <T> List<T> singletonList(T o) {

return new SingletonList<>(o);

}

下面是SingletonList静态类的定义

    private static class SingletonList<E>
        extends AbstractList<E>
        implements RandomAccess, Serializable {
 
        private static final long serialVersionUID = 3093736618740652951L;
 
        private final E element;
 
        SingletonList(E obj)                {element = obj;}
 
        public Iterator<E> iterator() {
            return singletonIterator(element);
        }
 
        public int size()                   {return 1;}
 
        public boolean contains(Object obj) {return eq(obj, element);}
 
        public E get(int index) {
            if (index != 0)
              throw new IndexOutOfBoundsException("Index: "+index+", Size: 1");
            return element;
        }
 
        // Override default methods for Collection
        @Override
        public void forEach(Consumer<? super E> action) {
            action.accept(element);
        }
        @Override
        public boolean removeIf(Predicate<? super E> filter) {
            throw new UnsupportedOperationException();
        }
        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            throw new UnsupportedOperationException();
        }
        @Override
        public void sort(Comparator<? super E> c) {
        }
        @Override
        public Spliterator<E> spliterator() {
            return singletonSpliterator(element);
        }
    }

private static class SingletonList<E>

extends AbstractList<E>

implements RandomAccess, Serializable {

private static final long serialVersionUID = 3093736618740652951L;

private final E element;

SingletonList(E obj) {element = obj;}

public Iterator<E> iterator() {

return singletonIterator(element);

}

public int size() {return 1;}

public boolean contains(Object obj) {return eq(obj, element);}

public E get(int index) {

if (index != 0)

throw new IndexOutOfBoundsException("Index: "+index+", Size: 1");

return element;

}

// Override default methods for Collection

@Override

public void forEach(Consumer<? super E> action) {

action.accept(element);

}

@Override

public boolean removeIf(Predicate<? super E> filter) {

throw new UnsupportedOperationException();

}

@Override

public void replaceAll(UnaryOperator<E> operator) {

throw new UnsupportedOperationException();

}

@Override

public void sort(Comparator<? super E> c) {

}

@Override

public Spliterator<E> spliterator() {

return singletonSpliterator(element);

}

上面的源码中可以看到，静态类中并没有重新add、delete、set等方法。所以通过Collections.singletonList初始化的List是不能执行上述方法的。

Collections.emptyList()

Collections.emptyList在日常开发中也比较常用，如果一个方法需要返回一个空List,并且后续不用再新增元素进去，我们完全可以直接返回Collections.emptyList()而不是new ArrayList;这样不用每次都去创建一个新对象。

    public static final <T> List<T> emptyList() {
        return (List<T>) EMPTY_LIST;
    }

public static final <T> List<T> emptyList() {

return (List<T>) EMPTY_LIST;

}

EMPTY_LIST如下

public static final List EMPTY_LIST = new EmptyList<>();

1	public static final List EMPTY_LIST = new EmptyList<>();

Collections中其他类似方法

public static <T> Set<T> singleton(T o);
 
public static <T> List<T> singletonList(T o);
 
public static <K,V> Map<K,V> singletonMap(K key, V value);
 
// 或者直接调用常量 EMPTY_LIST
public static final <T> List<T> emptyList();
 
//或者直接调用常量 EMPTY_MAP
public static final <K,V> Map<K,V> emptyMap();
 
//或者直接调用常量 EMPTY_SET
public static final <T> Set<T> emptySet()

public static <T> Set<T> singleton(T o);

public static <T> List<T> singletonList(T o);

public static <K,V> Map<K,V> singletonMap(K key, V value);

// 或者直接调用常量 EMPTY_LIST

public static final <T> List<T> emptyList();

//或者直接调用常量 EMPTY_MAP

public static final <K,V> Map<K,V> emptyMap();

//或者直接调用常量 EMPTY_SET

public static final <T> Set<T> emptySet()

参考链接

另一种绕过Android P以上非公开API限制的办法

去年发布的 Android P 上引入了针对非公开 API 的限制，对开发者来说，这绝对是有史以来最重大的变化之一。前天 Google 发布了 Android Q 的 Beta 版，越来越多的 API 被加入了黑名单，而且 Google 要求下半年 APP 必须 target 28，这意味着现在的深灰名单也会生效；可以预见，在不久的将来，我们要跟大量的 API 说再见了。

去年我给出了一种绕过Android P对非SDK接口限制的简单方法，经验证，这办法在 Android Q 的 Beta 版上依然能正常使用。虽然这个方法需要进行内存搜索，理论上有可能失败，但实际上它曾在 VirtualXposed 和太极中得到了较为广泛的验证，从未收到过由于反射失败而导致问题的反馈。而且据我所知，有若干用户量不少的 APP 在线上使用 FreeReflection 库，想来应该也是没有问题的吧。

不过今天，我打算给出另外一种绕过限制的办法。这个办法目前来说是最优方案，我个人使用了一个多月，不存在任何问题。

上次分析系统是如何施加这个限制的时候，我们提到了几种方式，最终给出了一种修改 runtime flag 的办法；其中我们提到，系统有一个 fn_caller_is_trusted 条件：如果调用者是系统类，那么就允许被调用。这是显而易见的，毕竟这些私有 API 就是给系统用的，如果系统自己都被拒绝了，这是在玩锤子呢？

也就是说，如果我们能以系统类的身份去反射，那么就能畅通无阻。问题是，我们如何以「系统的身份去反射」呢？一种最常见的办法是，我们自己写一个类，然后通过某种途径把这个类的 ClassLoader 设置为系统的 ClassLoader，再借助这个类去反射其他类。但是这里的「通过某种途径」依然要使用一些黑科技才能实现，与修改 flags / inline hook 无本质区别。

以系统类的身份去反射 有两个意思，1. 直接把我们自己变成系统类；2. 借助系统类去调用反射。我们一个个分析。

「直接把我们自己变成系统类」这个方式有童鞋可能觉得天方夜谭，APP 的类怎么可能成为系统类？但是，一定不要被自己的固有思维给局限，一切皆有可能！我们知道，对APP来说，所谓的系统类就是被 BootstrapClassLoader 加载的类，这个 ClassLoader 并非普通的 DexClassLoader，因此我们无法通过插入 dex path的方式注入类。但是，Android 的 ART 在 Android O 上引入了 JVMTI，JVMTI 提供了将某一个类转换为 BootstrapClassLoader 中的类的方法！具体来说，我们写一个类暴露反射相关的接口，然后通过 JVMTI 提供的 AddToBootstrapClassLoaderSearch将此类加入 BootstrapClassLoader 就实现目的了。不过，JVMTI 要在 release 版本的 APP 上运行依然需要 Hack，所以这种途径与其他的黑科技无本质区别。

第二种方法，「借助系统的类去反射」也就是说，如果系统有一个方法systemMethod，这个systemMethod 去调用反射相反的方法，那么systemMethod毋庸置疑会反射成功。但是，我们从哪去找到这么一个方法给我们用？事实上，我们不仅能找到这样的方法，而且这个方法能帮助我们调用任意的函数，那就是反射本身！可能你已经绕晕了，我解释一下：

首先，我们通过反射 API 拿到 getDeclaredMethod 方法。getDeclaredMethod 是 public 的，不存在问题；这个通过反射拿到的方法我们称之为元反射方法。
然后，我们通过刚刚反射拿到元反射方法去反射调用 getDeclardMethod。这里我们就实现了以系统身份去反射的目的——反射相关的 API 都是系统类，因此我们的元反射方法也是被系统类加载的方法；所以我们的元反射方法调用的 getDeclardMethod 会被认为是系统调用的，可以反射任意的方法。

伪代码如下：

Method metaGetDeclaredMethod = Class.class.getDeclaredMethod("getDeclaredMethod", String.class, Class[].class); // 公开API，无问题

Method hiddenMethod = metaGetDeclaredMethod.invoke(hiddenClass, "hiddenMethod", "hiddenMethod参数列表"); // 系统类通过反射使用隐藏 API，检查直接通过。

hiddenMethod.invoke // 正确找到 Method 直接反射调用

Method metaGetDeclaredMethod = Class.class.getDeclaredMethod("getDeclaredMethod", String.class, Class[].class); // 公开API，无问题

Method hiddenMethod = metaGetDeclaredMethod.invoke(hiddenClass, "hiddenMethod", "hiddenMethod参数列表"); // 系统类通过反射使用隐藏 API，检查直接通过。

hiddenMethod.invoke // 正确找到 Method 直接反射调用

到这里，我们已经能通过「元反射」的方式去任意获取隐藏方法或者隐藏 Field 了。但是，如果我们所有使用的隐藏方法都要这么干，那还有点小麻烦。在上文中，我们后来发现，隐藏 API 调用还有「豁免」条件，具体代码如下：

if (shouldWarn || action == kDeny) {
    if (member_signature.IsExempted(runtime->GetHiddenApiExemptions())) {
      action = kAllow;
      // Avoid re-examining the exemption list next time.
      // Note this results in no warning for the member, which seems like what one would expect.
      // Exemptions effectively adds new members to the whitelist.
      MaybeWhitelistMember(runtime, member);
      return kAllow;
    }
    // 略    
}

if (shouldWarn || action == kDeny) {

if (member_signature.IsExempted(runtime->GetHiddenApiExemptions())) {

action = kAllow;

// Avoid re-examining the exemption list next time.

// Note this results in no warning for the member, which seems like what one would expect.

// Exemptions effectively adds new members to the whitelist.

MaybeWhitelistMember(runtime, member);

return kAllow;

}

// 略

}

只要 IsExempted 方法返回 true，就算这个方法在黑名单中，依然会被放行然后允许被调用。我们再观察一下IsExempted方法：

bool MemberSignature::IsExempted(const std::vector<std::string>& exemptions) {
  for (const std::string& exemption : exemptions) {
    if (DoesPrefixMatch(exemption)) {
      return true;
    }
  }
  return false;
}

bool MemberSignature::IsExempted(const std::vector<std::string>& exemptions) {

for (const std::string& exemption : exemptions) {

if (DoesPrefixMatch(exemption)) {

return true;

}

return false;

}

继续跟踪传递进来的参数 runtime->GetHiddenApiExemptions() 发现这玩意儿也是 runtime 里面的一个参数，既然如此，我们可以一不做二不休，仿照修改 runtime flag 的方式直接修改 hidden_api_exemptions_ 也能绕过去。但如果我们继续跟踪下去，会有个有趣的发现：这个API 竟然是暴露到 Java 层的，有一个对应的 VMRuntime.setHiddenApiExemptions Java方法；也就是说，只要我们通过 VMRuntime.setHiddenApiExemptions 设置下豁免条件，我们就能愉快滴使用反射了。

再结合上面这个方法，我们只需要通过「元反射」来反射调用 VMRuntime.setHiddenApiExemptions 就能将我们自己要使用的隐藏 API 全部都豁免掉了。更进一步，如果我们再观察下上面的 IsExempted 方法里面调用的 DoesPrefixMatch，发现这玩意儿在对方法签名进行前缀匹配；童鞋们，我们所有Java方法类的签名都是以 L开头啊！如果我们把直接传个 L进去，所有的隐藏API全部被赦免了！

详细代码在这里：https://github.com/tiann/FreeReflection

理论上讲，这个方案不存在兼容性问题。即使 ROM 删掉了 setHiddenApiExemptions 方法，我们依然可以用「元反射」的方式去反射隐藏API，并且所有的代码加起来不超过30行！当然，如果 Google 继续改进验证隐藏API调用的方法，这个方式可能会失效，但是目前的机制没有问题。

2025 年 1 月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31