/* * * Apache License * Version 2.0, January 2004 * http://www.apache.org/licenses/ * * TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION * * 1. Definitions. * * "License" shall mean the terms and conditions for use, reproduction, * and distribution as defined by Sections 1 through 9 of this document. * * "Licensor" shall mean the copyright owner or entity authorized by * the copyright owner that is granting the License. * * "Legal Entity" shall mean the union of the acting entity and all * other entities that control, are controlled by, or are under common * control with that entity. For the purposes of this definition, * "control" means (i) the power, direct or indirect, to cause the * direction or management of such entity, whether by contract or * otherwise, or (ii) ownership of fifty percent (50%) or more of the * outstanding shares, or (iii) beneficial ownership of such entity. * * "You" (or "Your") shall mean an individual or Legal Entity * exercising permissions granted by this License. * * "Source" form shall mean the preferred form for making modifications, * including but not limited to software source code, documentation * source, and configuration files. * * "Object" form shall mean any form resulting from mechanical * transformation or translation of a Source form, including but * not limited to compiled object code, generated documentation, * and conversions to other media types. * * "Work" shall mean the work of authorship, whether in Source or * Object form, made available under the License, as indicated by a * copyright notice that is included in or attached to the work * (an example is provided in the Appendix below). * * "Derivative Works" shall mean any work, whether in Source or Object * form, that is based on (or derived from) the Work and for which the * editorial revisions, annotations, elaborations, or other modifications * represent, as a whole, an original work of authorship. For the purposes * of this License, Derivative Works shall not include works that remain * separable from, or merely link (or bind by name) to the interfaces of, * the Work and Derivative Works thereof. * * "Contribution" shall mean any work of authorship, including * the original version of the Work and any modifications or additions * to that Work or Derivative Works thereof, that is intentionally * submitted to Licensor for inclusion in the Work by the copyright owner * or by an individual or Legal Entity authorized to submit on behalf of * the copyright owner. For the purposes of this definition, "submitted" * means any form of electronic, verbal, or written communication sent * to the Licensor or its representatives, including but not limited to * communication on electronic mailing lists, source code control systems, * and issue tracking systems that are managed by, or on behalf of, the * Licensor for the purpose of discussing and improving the Work, but * excluding communication that is conspicuously marked or otherwise * designated in writing by the copyright owner as "Not a Contribution." * * "Contributor" shall mean Licensor and any individual or Legal Entity * on behalf of whom a Contribution has been received by Licensor and * subsequently incorporated within the Work. * * 2. Grant of Copyright License. Subject to the terms and conditions of * this License, each Contributor hereby grants to You a perpetual, * worldwide, non-exclusive, no-charge, royalty-free, irrevocable * copyright license to reproduce, prepare Derivative Works of, * publicly display, publicly perform, sublicense, and distribute the * Work and such Derivative Works in Source or Object form. * * 3. Grant of Patent License. Subject to the terms and conditions of * this License, each Contributor hereby grants to You a perpetual, * worldwide, non-exclusive, no-charge, royalty-free, irrevocable * (except as stated in this section) patent license to make, have made, * use, offer to sell, sell, import, and otherwise transfer the Work, * where such license applies only to those patent claims licensable * by such Contributor that are necessarily infringed by their * Contribution(s) alone or by combination of their Contribution(s) * with the Work to which such Contribution(s) was submitted. If You * institute patent litigation against any entity (including a * cross-claim or counterclaim in a lawsuit) alleging that the Work * or a Contribution incorporated within the Work constitutes direct * or contributory patent infringement, then any patent licenses * granted to You under this License for that Work shall terminate * as of the date such litigation is filed. * * 4. Redistribution. You may reproduce and distribute copies of the * Work or Derivative Works thereof in any medium, with or without * modifications, and in Source or Object form, provided that You * meet the following conditions: * * (a) You must give any other recipients of the Work or * Derivative Works a copy of this License; and * * (b) You must cause any modified files to carry prominent notices * stating that You changed the files; and * * (c) You must retain, in the Source form of any Derivative Works * that You distribute, all copyright, patent, trademark, and * attribution notices from the Source form of the Work, * excluding those notices that do not pertain to any part of * the Derivative Works; and * * (d) If the Work includes a "NOTICE" text file as part of its * distribution, then any Derivative Works that You distribute must * include a readable copy of the attribution notices contained * within such NOTICE file, excluding those notices that do not * pertain to any part of the Derivative Works, in at least one * of the following places: within a NOTICE text file distributed * as part of the Derivative Works; within the Source form or * documentation, if provided along with the Derivative Works; or, * within a display generated by the Derivative Works, if and * wherever such third-party notices normally appear. The contents * of the NOTICE file are for informational purposes only and * do not modify the License. You may add Your own attribution * notices within Derivative Works that You distribute, alongside * or as an addendum to the NOTICE text from the Work, provided * that such additional attribution notices cannot be construed * as modifying the License. * * You may add Your own copyright statement to Your modifications and * may provide additional or different license terms and conditions * for use, reproduction, or distribution of Your modifications, or * for any such Derivative Works as a whole, provided Your use, * reproduction, and distribution of the Work otherwise complies with * the conditions stated in this License. * * 5. Submission of Contributions. Unless You explicitly state otherwise, * any Contribution intentionally submitted for inclusion in the Work * by You to the Licensor shall be under the terms and conditions of * this License, without any additional terms or conditions. * Notwithstanding the above, nothing herein shall supersede or modify * the terms of any separate license agreement you may have executed * with Licensor regarding such Contributions. * * 6. Trademarks. This License does not grant permission to use the trade * names, trademarks, service marks, or product names of the Licensor, * except as required for reasonable and customary use in describing the * origin of the Work and reproducing the content of the NOTICE file. * * 7. Disclaimer of Warranty. Unless required by applicable law or * agreed to in writing, Licensor provides the Work (and each * Contributor provides its Contributions) on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or * implied, including, without limitation, any warranties or conditions * of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A * PARTICULAR PURPOSE. You are solely responsible for determining the * appropriateness of using or redistributing the Work and assume any * risks associated with Your exercise of permissions under this License. * * 8. Limitation of Liability. In no event and under no legal theory, * whether in tort (including negligence), contract, or otherwise, * unless required by applicable law (such as deliberate and grossly * negligent acts) or agreed to in writing, shall any Contributor be * liable to You for damages, including any direct, indirect, special, * incidental, or consequential damages of any character arising as a * result of this License or out of the use or inability to use the * Work (including but not limited to damages for loss of goodwill, * work stoppage, computer failure or malfunction, or any and all * other commercial damages or losses), even if such Contributor * has been advised of the possibility of such damages. * * 9. Accepting Warranty or Additional Liability. While redistributing * the Work or Derivative Works thereof, You may choose to offer, * and charge a fee for, acceptance of support, warranty, indemnity, * or other liability obligations and/or rights consistent with this * License. However, in accepting such obligations, You may act only * on Your own behalf and on Your sole responsibility, not on behalf * of any other Contributor, and only if You agree to indemnify, * defend, and hold each Contributor harmless for any liability * incurred by, or claims asserted against, such Contributor by reason * of your accepting any such warranty or additional liability. * * END OF TERMS AND CONDITIONS * * APPENDIX: How to apply the Apache License to your work. * * To apply the Apache License to your work, attach the following * boilerplate notice, with the fields enclosed by brackets "[]" * replaced with your own identifying information. (Don't include * the brackets!) The text should be enclosed in the appropriate * comment syntax for the file format. We also recommend that a * file or class name and description of purpose be included on the * same "printed page" as the copyright notice for easier * identification within third-party archives. * * Copyright 2016 Alibaba Group * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * * */ package android.taobao.atlas.startup.patch.releaser; /** * Created by lilong on 16/12/21. */ import android.os.Build; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.taobao.atlas.runtime.RuntimeVariables; import android.taobao.atlas.startup.DexFileCompat; import android.taobao.atlas.startup.patch.KernalConstants; import android.util.Log; import java.io.File; import java.io.FilenameFilter; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Method; import java.util.*; import java.util.Enumeration; import java.util.concurrent.CountDownLatch; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.regex.Matcher; import java.util.regex.Pattern; import dalvik.system.DexFile; public class BundleReleaser { private static final int MSG_ID_DEX_RELEASE_DONE = 1; public static final int MSG_ID_DEX_OPT_DONE = 2; private static final int MSG_ID_RESOURCE_RELEASE_DONE = 3; private static final int MSG_ID_SOLIB_RELEASE_DONE = 4; private static final int MSG_ID_RELEASE_DONE = 5; private static final int MSG_ID_RELEASE_FAILED = 6; private static final String TAG = BundleReleaser.class.getSimpleName(); private static final String DEX_SUFFIX = ".dex"; private boolean isReleasing = false; private ExecutorService service; private File reversionDir; private Handler handler; private ProcessCallBack processCallBack; private File apkFile; private boolean hasReleased; private boolean externalStorage = false; public DexFile[] getDexFile() { return dexFiles; } private DexFile[] dexFiles = null; public BundleReleaser(final File reversionDir,boolean hasReleased) { this.hasReleased = hasReleased; this.reversionDir = reversionDir; if(!reversionDir.getAbsolutePath().startsWith(KernalConstants.baseContext.getFilesDir().getAbsolutePath())){ externalStorage = true; } if (!(Looper.getMainLooper() == Looper.myLooper())) { if (Looper.myLooper() == null) Looper.prepare(); } handler = new Handler(new Handler.Callback() { @Override public boolean handleMessage(Message msg) { try { return handleMsg(msg); } catch (IOException e) { e.printStackTrace(); } return false; } }); this.service = Executors.newFixedThreadPool(3); } private boolean handleMsg(Message msg) throws IOException { switch (msg.what) { case MSG_ID_DEX_OPT_DONE: isReleasing = false; if (processCallBack != null) processCallBack.onFinish(MSG_ID_DEX_OPT_DONE); try { release(ReleaseType.RESOURCE); } catch (IOException e) { e.printStackTrace(); } return true; case MSG_ID_RELEASE_FAILED: if (processCallBack != null) { processCallBack.onFailed(); } break; case MSG_ID_DEX_RELEASE_DONE: if (processCallBack != null) { processCallBack.onFinish(MSG_ID_DEX_RELEASE_DONE); } dexOptimization(); return true; case MSG_ID_RELEASE_DONE: if (processCallBack != null) { processCallBack.onAllFinish(); } return true; case MSG_ID_RESOURCE_RELEASE_DONE: if (processCallBack != null) { processCallBack.onFinish(MSG_ID_RESOURCE_RELEASE_DONE); } try { release(ReleaseType.SOLIB); } catch (IOException e) { e.printStackTrace(); } break; default: break; } return false; } public void release(final ProcessCallBack processCallBack, final File bundleFile,boolean start) throws IOException { Log.e(TAG, "release doing--->" + isReleasing); apkFile = bundleFile; if (isReleasing) { return; } isReleasing = true; this.processCallBack = processCallBack; if (!start) { release(ReleaseType.DEX); }else { dexOptimization(); if (!handler.hasMessages(MSG_ID_RELEASE_FAILED)) { processCallBack.onFinish(MSG_ID_DEX_OPT_DONE); processCallBack.onAllFinish(); // handler.removeCallbacksAndMessages(null); }else { processCallBack.onFailed(); // handler.removeCallbacksAndMessages(null); } } } public void release(final ReleaseType releaseType) throws IOException { switch (releaseType) { case DEX: try { Log.e(TAG, "DexReleaser start!"); boolean result = DexReleaser.releaseDexes(apkFile, reversionDir,externalStorage); Log.e(TAG, "DexReleaser done!----->"+result); Message message = handler.obtainMessage(); if (result) { message.what = MSG_ID_DEX_RELEASE_DONE; } else { message.what = MSG_ID_RELEASE_FAILED; } handler.sendMessage(message); } catch (IOException e) { e.printStackTrace(); } break; // case RESOURCE: // try { // Log.e(TAG, "ResourceReleaser start!"); // boolean result = ResourceReleaser.releaseResource(apkFile, reversionDir); // Log.e(TAG, "ResourceReleaser done!----->"+result); // // Message message = handler.obtainMessage(); // if (result) { // message.what = MSG_ID_RESOURCE_RELEASE_DONE; // } else { // message.what = MSG_ID_RELEASE_FAILED; // } // handler.sendMessage(message); // } catch (IOException e) { // e.printStackTrace(); // } // break; // case SOLIB: // try { // Log.e(TAG, "NativeLibReleaser start!"); //// boolean result = NativeLibReleaser.releaseLibs(apkFile, reversionDir); // Log.e(TAG, "NativeLibReleaser done!----->"+result); // Message message = handler.obtainMessage(); // if (result) { // message.what = MSG_ID_RELEASE_DONE; // } else { // message.what = MSG_ID_RELEASE_FAILED; // } // handler.sendMessage(message); // } catch (IOException e) { // e.printStackTrace(); // } // break; default: break; } } private void dexOptimization() { Log.e(TAG, "dexOptimization start"); File[] validDexes = reversionDir.listFiles(new FilenameFilter() { @Override public boolean accept(File dir,String pathname) { if (!DexReleaser.isArt() || externalStorage) { return pathname.endsWith(DEX_SUFFIX); } else { return pathname.endsWith(".zip"); } } }); File[] rawMainDexZip = reversionDir.listFiles(new FilenameFilter() { @Override public boolean accept(File dir, String pathname) { return pathname.endsWith(".zip"); } }); if (validDexes!= null && validDexes.length > 0) { validDexes = sortDexs(validDexes); if (Build.VERSION.SDK_INT >= 21 && Build.VERSION.SDK_INT <= 24) { PatchDexProfile.instance(RuntimeVariables.androidApplication).disableJitCompile(); } }else if (rawMainDexZip!= null){ validDexes = rawMainDexZip; } dexFiles = new DexFile[validDexes.length]; if(!hasReleased) { Log.e(TAG,"start dexopt | hasRelease : "+hasReleased); final CountDownLatch countDownLatch = new CountDownLatch(validDexes.length); for (int i = 0; i < validDexes.length; i++) { final int j = i; final File[] finalValidDexes = validDexes; service.submit(new Runnable() { @Override public void run() { dexFiles[j] = dexoptInternal(finalValidDexes[j]); countDownLatch.countDown(); } }); } try { countDownLatch.await(); } catch (InterruptedException e) { e.printStackTrace(); } }else{ Log.e(TAG,"start dexopt | hasRelease : "+hasReleased); for (int i = 0; i < validDexes.length; i++) { dexFiles[i] = dexoptInternal(validDexes[i]); } } Log.e(TAG, "dex opt done"); handler.sendMessage(handler.obtainMessage(MSG_ID_DEX_OPT_DONE)); } private String[] toString(File[] validDexes) { String[]ss = new String[validDexes.length]; for (int i = 0; i < ss.length; i ++){ ss[i] = validDexes[i].getPath(); } return ss; } private File[] sortDexs(File[] validDexes) { if (validDexes == null){ return validDexes; }else { List<File>files = Arrays.asList(validDexes); Collections.sort(files, new Comparator<File>() { @Override public int compare(File lhs, File rhs) { if (lhs.getName().equals("classes.dex")) { return -1; } else if (rhs.getName().equals("classes.dex")) { return 1; } return Integer.valueOf(lhs.getName().substring(7, lhs.getName().indexOf("."))) - Integer.valueOf(rhs.getName().substring(7, rhs.getName().indexOf("."))); } }); return files.toArray(new File[0]); } } private DexFile dexoptInternal(File validDex){ long startTime = System.currentTimeMillis(); DexFile dexFile = null; String optimizedPath = optimizedPathFor(validDex, dexOptDir()); try { if(!externalStorage) { if(!new File(optimizedPath).exists()){ Log.e(TAG,"odex not exist"); } }else{ //interpretOnly if(Build.VERSION.SDK_INT>=21 && isVMMultidexCapable(System.getProperty("java.vm.version"))) { optimizedPath = KernalConstants.baseContext.getFilesDir()+File.separator+"fake.dex"; new File(optimizedPath).createNewFile(); dexFile = DexFileCompat.loadDex(KernalConstants.baseContext, validDex.getPath(), optimizedPath, 0); }else{ dexFile = DexFileCompat.loadDex(KernalConstants.baseContext,validDex.getPath(), optimizedPath,0); } } boolean result = verifyDexFile(dexFile,optimizedPath); if (!result) { handler.sendMessage(handler.obtainMessage(MSG_ID_RELEASE_FAILED)); }else { Log.e(TAG,"oat length:"+String.valueOf(new File(optimizedPath).length())); } } catch (Exception e) { e.printStackTrace(); handler.sendMessage(handler.obtainMessage(MSG_ID_RELEASE_FAILED)); } finally { Log.e(TAG, String.format("dex %s consume %d ms", validDex.getAbsolutePath(), System.currentTimeMillis() - startTime)); } return dexFile; } private boolean verifyDexFile(DexFile dexFile,String optimizedPath) throws IOException { if (dexFile != null) { if(externalStorage){ return true; } if (!checkDexValid(dexFile)) { return false; } return true; } return false; } public boolean checkDexValid(DexFile odexFile) throws IOException { if (DexReleaser.isArt()) { String applicationName = KernalConstants.RAW_APPLICATION_NAME; try { Enumeration<String> enumeration = odexFile.entries(); while (enumeration.hasMoreElements()) { if (enumeration.nextElement().replace("/", ".").equals(applicationName)) { return true; } } return false; } catch (Throwable e) { e.printStackTrace(); return false; } } return true; } private String optimizedPathFor(File path, File optimizedDirectory) { String fileName = path.getName(); if (!fileName.endsWith(DEX_SUFFIX)) { int lastDot = fileName.lastIndexOf("."); if (lastDot < 0) { fileName += DEX_SUFFIX; } else { StringBuilder sb = new StringBuilder(lastDot + 4); sb.append(fileName, 0, lastDot); sb.append(DEX_SUFFIX); fileName = sb.toString(); } } File result = new File(optimizedDirectory, fileName); return result.getPath(); } private File dexOptDir() { File optDir = new File(reversionDir, "opt"); if (!optDir.exists()){ optDir.mkdirs(); } return optDir; } public void close(){ if (!(Looper.getMainLooper() == Looper.myLooper())){ Looper.myLooper().quit(); } handler.removeCallbacksAndMessages(null); handler = null; service.shutdown(); } /** * Identifies if the current VM has a native support for multidex, meaning there is no need for * additional installation by this library. * @return true if the VM handles multidex */ /* package visible for test */ static boolean isVMMultidexCapable(String versionString) { boolean isMultidexCapable = false; if (versionString != null) { Matcher matcher = Pattern.compile("(\\d+)\\.(\\d+)(\\.\\d+)?").matcher(versionString); if (matcher.matches()) { try { int major = Integer.parseInt(matcher.group(1)); int minor = Integer.parseInt(matcher.group(2)); isMultidexCapable = (major > 2) || ((major == 2) && (minor >= 1)); } catch (NumberFormatException e) { // let isMultidexCapable be false } } } Log.i(TAG, "VM with version " + versionString + (isMultidexCapable ? " has multidex support" : " does not have multidex support")); return isMultidexCapable; } private void dexOat(String dexFilePath,String oatFilePath,String targetISA) throws IOException, InterruptedException { final List<String> commandAndParams = new ArrayList<>(); commandAndParams.add("dex2oat"); if (Build.VERSION.SDK_INT >= 24) { commandAndParams.add("--runtime-arg"); commandAndParams.add("-classpath"); commandAndParams.add("--runtime-arg"); commandAndParams.add("&"); } commandAndParams.add("--dex-file=" + dexFilePath); commandAndParams.add("--oat-file=" + oatFilePath); commandAndParams.add("--instruction-set=" + targetISA); if (Build.VERSION.SDK_INT > 25) { commandAndParams.add("--compiler-filter=quicken"); } else { commandAndParams.add("--compiler-filter=interpret-only"); } final ProcessBuilder pb = new ProcessBuilder(commandAndParams); pb.redirectErrorStream(true); final Process dex2oatProcess = pb.start(); StreamConsumer.consumeInputStream(dex2oatProcess.getInputStream()); StreamConsumer.consumeInputStream(dex2oatProcess.getErrorStream()); final int ret = dex2oatProcess.waitFor(); if (ret != 0) { throw new IOException("dex2oat works unsuccessfully, exit code: " + ret); } } public interface ProcessCallBack{ void onFailed() throws IOException; void onFinish(int event); void onAllFinish(); } private static class StreamConsumer { static final Executor STREAM_CONSUMER = Executors.newSingleThreadExecutor(); static void consumeInputStream(final InputStream is) { STREAM_CONSUMER.execute(new Runnable() { @Override public void run() { if (is == null) { return; } final byte[] buffer = new byte[256]; try { while ((is.read(buffer)) > 0) { // To satisfy checkstyle rules. } } catch (IOException ignored) { // Ignored. } finally { try { is.close(); } catch (Exception ignored) { // Ignored. } } } }); } } public static String getCurrentInstructionSet() throws Exception { String currentInstructionSet = null; if (currentInstructionSet != null) { return currentInstructionSet; } Class<?> clazz = Class.forName("dalvik.system.VMRuntime"); Method currentGet = clazz.getDeclaredMethod("getCurrentInstructionSet"); currentInstructionSet = (String) currentGet.invoke(null); Log.d(TAG, "getCurrentInstructionSet:" + currentInstructionSet); return currentInstructionSet; } }