New Crowdin updates

core/java/android/app/ActivityManagerInternal.java

@@ -259,7 +259,7 @@ public abstract ComponentName startServiceInPackage(int uid, Intent service,
             String resolvedType, boolean fgRequired, String callingPackage, int userId,
             boolean allowBackgroundActivityStarts) throws TransactionTooLargeException;
 
-    public abstract void disconnectActivityFromServices(Object connectionHolder, Object conns);
+    public abstract void disconnectActivityFromServices(Object connectionHolder);
     public abstract void cleanUpServices(int userId, ComponentName component, Intent baseIntent);
     public abstract ActivityInfo getActivityInfoForUser(ActivityInfo aInfo, int userId);
     public abstract void ensureBootCompleted();

core/java/android/app/ActivityThread.java

@@ -4333,13 +4333,14 @@ public void handleResumeActivity(IBinder token, boolean finalStateRequest, boole
                 l.softInputMode = (l.softInputMode
                         & (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))
                         | forwardBit;
-                if (r.activity.mVisibleFromClient) {
-                    ViewManager wm = a.getWindowManager();
-                    View decor = r.window.getDecorView();
-                    wm.updateViewLayout(decor, l);
-                }
             }
 
+            if (r.activity.mVisibleFromClient) {
+                ViewManager wm = a.getWindowManager();
+                View decor = r.window.getDecorView();
+                wm.updateViewLayout(decor, l);
+             }
+
             r.activity.mVisibleFromServer = true;
             mNumVisibleActivities++;
             if (r.activity.mVisibleFromClient) {

core/java/android/net/Network.java

@@ -105,6 +105,8 @@ public class Network implements Parcelable {
     // code search audits are possible.
     private final transient boolean mPrivateDnsBypass;
 
+    private java.net.Proxy mProxy = null;
+
     /**
      * @hide
      */
@@ -315,6 +317,22 @@ private void maybeInitUrlConnectionFactory() {
         }
     }
 
+    private java.net.Proxy getProxy() throws IOException {
+        if (mProxy == null) {
+            final ConnectivityManager cm = ConnectivityManager.getInstanceOrNull();
+            if (cm == null) {
+                throw new IOException("No ConnectivityManager yet constructed, please construct one");
+            }
+            final ProxyInfo proxyInfo = cm.getProxyForNetwork(this);
+            if (proxyInfo != null) {
+                mProxy = proxyInfo.makeProxy();
+            } else {
+                mProxy = java.net.Proxy.NO_PROXY;
+            }
+        }
+        return mProxy;
+    }
+
     /**
      * Opens the specified {@link URL} on this {@code Network}, such that all traffic will be sent
      * on this Network. The URL protocol must be {@code HTTP} or {@code HTTPS}.
@@ -325,19 +343,7 @@ private void maybeInitUrlConnectionFactory() {
      * @see java.net.URL#openConnection()
      */
     public URLConnection openConnection(URL url) throws IOException {
-        final ConnectivityManager cm = ConnectivityManager.getInstanceOrNull();
-        if (cm == null) {
-            throw new IOException("No ConnectivityManager yet constructed, please construct one");
-        }
-        // TODO: Should this be optimized to avoid fetching the global proxy for every request?
-        final ProxyInfo proxyInfo = cm.getProxyForNetwork(this);
-        final java.net.Proxy proxy;
-        if (proxyInfo != null) {
-            proxy = proxyInfo.makeProxy();
-        } else {
-            proxy = java.net.Proxy.NO_PROXY;
-        }
-        return openConnection(url, proxy);
+        return openConnection(url, getProxy());
     }
 
     /**

core/java/android/os/ZygoteProcess.java

@@ -81,7 +81,7 @@ public class ZygoteProcess {
      * not be used if the devices has a DeviceConfig profile pushed to it that contains a value for
      * this key.
      */
-    private static final String USAP_POOL_ENABLED_DEFAULT = "false";
+    private static final String USAP_POOL_ENABLED_DEFAULT = "true";
 
     /**
      * The name of the socket used to communicate with the primary zygote.

core/java/android/provider/Settings.java

@@ -11445,6 +11445,12 @@ public boolean validate(@Nullable String value) {
          */
         public static final String HARDWARE_KEYS_ENABLE = "hardware_keys_enable";
 
+        /**
+         * Whether face unlock is allowed only on security view.
+         * @hide
+         */
+        public static final String FACE_UNLOCK_ALWAYS_REQUIRE_SWIPE = "face_unlock_always_require_swipe";
+
         /**
          * This are the settings to be backed up.
          *

core/java/android/security/net/config/PinSet.java

@@ -22,6 +22,7 @@
 
 /** @hide */
 public final class PinSet {
+    private static Set<String> algorithms;
     public static final PinSet EMPTY_PINSET =
             new PinSet(Collections.<Pin>emptySet(), Long.MAX_VALUE);
     public final long expirationTime;
@@ -36,10 +37,11 @@ public PinSet(Set<Pin> pins, long expirationTime) {
     }
 
     Set<String> getPinAlgorithms() {
-        // TODO: Cache this.
-        Set<String> algorithms = new ArraySet<String>();
-        for (Pin pin : pins) {
-            algorithms.add(pin.digestAlgorithm);
+        if(algorithms == null){
+            algorithms = new ArraySet<String>();
+            for (Pin pin : pins) {
+                algorithms.add(pin.digestAlgorithm);
+            }
         }
         return algorithms;
     }

core/java/android/util/apk/ApkSignatureVerifier.java

@@ -28,6 +28,8 @@
 import android.content.pm.PackageParser.SigningDetails.SignatureSchemeVersion;
 import android.content.pm.Signature;
 import android.os.Trace;
+import android.util.ArrayMap;
+import android.util.Slog;
 import android.util.jar.StrictJarFile;
 
 import com.android.internal.util.ArrayUtils;
@@ -46,6 +48,9 @@
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.zip.ZipEntry;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.LinkedBlockingQueue;
 
 /**
  * Facade class that takes care of the details of APK verification on
@@ -57,6 +62,12 @@ public class ApkSignatureVerifier {
 
     private static final AtomicReference<byte[]> sBuffer = new AtomicReference<>();
 
+    private static final String TAG = "ApkSignatureVerifier";
+
+    // multithread verification
+    private static final int NUMBER_OF_CORES =
+            Runtime.getRuntime().availableProcessors() >= 4 ? 4 : Runtime.getRuntime().availableProcessors() ;
+
     /**
      * Verifies the provided APK and returns the certificates associated with each signer.
      *
@@ -160,8 +171,9 @@ public static PackageParser.SigningDetails verify(String apkPath,
     private static PackageParser.SigningDetails verifyV1Signature(
             String apkPath, boolean verifyFull)
             throws PackageParserException {
-        StrictJarFile jarFile = null;
-
+        int objectNumber = verifyFull ? NUMBER_OF_CORES : 1;
+        StrictJarFile[] jarFile = new StrictJarFile[objectNumber];
+        final ArrayMap<String, StrictJarFile> strictJarFiles = new ArrayMap<String, StrictJarFile>();
         try {
             final Certificate[][] lastCerts;
             final Signature[] lastSigs;
@@ -170,21 +182,23 @@ private static PackageParser.SigningDetails verifyV1Signature(
 
             // we still pass verify = true to ctor to collect certs, even though we're not checking
             // the whole jar.
-            jarFile = new StrictJarFile(
-                    apkPath,
-                    true, // collect certs
-                    verifyFull); // whether to reject APK with stripped v2 signatures (b/27887819)
+            for (int i = 0; i < objectNumber; i++) {
+                jarFile[i] = new StrictJarFile(
+                        apkPath,
+                        true, // collect certs
+                        verifyFull); // whether to reject APK with stripped v2 signatures (b/27887819)
+            }
             final List<ZipEntry> toVerify = new ArrayList<>();
 
             // Gather certs from AndroidManifest.xml, which every APK must have, as an optimization
             // to not need to verify the whole APK when verifyFUll == false.
-            final ZipEntry manifestEntry = jarFile.findEntry(
+            final ZipEntry manifestEntry = jarFile[0].findEntry(
                     PackageParser.ANDROID_MANIFEST_FILENAME);
             if (manifestEntry == null) {
                 throw new PackageParserException(INSTALL_PARSE_FAILED_BAD_MANIFEST,
                         "Package " + apkPath + " has no manifest");
             }
-            lastCerts = loadCertificates(jarFile, manifestEntry);
+            lastCerts = loadCertificates(jarFile[0], manifestEntry);
             if (ArrayUtils.isEmpty(lastCerts)) {
                 throw new PackageParserException(INSTALL_PARSE_FAILED_NO_CERTIFICATES, "Package "
                         + apkPath + " has no certificates at entry "
@@ -194,7 +208,7 @@ private static PackageParser.SigningDetails verifyV1Signature(
 
             // fully verify all contents, except for AndroidManifest.xml  and the META-INF/ files.
             if (verifyFull) {
-                final Iterator<ZipEntry> i = jarFile.iterator();
+                final Iterator<ZipEntry> i = jarFile[0].iterator();
                 while (i.hasNext()) {
                     final ZipEntry entry = i.next();
                     if (entry.isDirectory()) continue;
@@ -205,24 +219,93 @@ private static PackageParser.SigningDetails verifyV1Signature(
 
                     toVerify.add(entry);
                 }
-
+                class VerificationData {
+                    public Exception exception;
+                    public int exceptionFlag;
+                    public boolean wait;
+                    public int index;
+                    public Object objWaitAll;
+                    public boolean shutDown;
+                }
+                VerificationData vData = new VerificationData();
+                vData.objWaitAll = new Object();
+                final ThreadPoolExecutor verificationExecutor = new ThreadPoolExecutor(
+                        NUMBER_OF_CORES,
+                        NUMBER_OF_CORES,
+                        1,/*keep alive time*/
+                        TimeUnit.SECONDS,
+                        new LinkedBlockingQueue<Runnable>());
                 for (ZipEntry entry : toVerify) {
-                    final Certificate[][] entryCerts = loadCertificates(jarFile, entry);
-                    if (ArrayUtils.isEmpty(entryCerts)) {
-                        throw new PackageParserException(INSTALL_PARSE_FAILED_NO_CERTIFICATES,
-                                "Package " + apkPath + " has no certificates at entry "
-                                        + entry.getName());
+                    Runnable verifyTask = new Runnable(){
+                        public void run() {
+                            try {
+                                if (vData.exceptionFlag != 0 ) {
+                                    Slog.w(TAG, "VerifyV1 exit with exception " + vData.exceptionFlag);
+                                    return;
+                                }
+                                String tid = Long.toString(Thread.currentThread().getId());
+                                StrictJarFile tempJarFile;
+                                synchronized (strictJarFiles) {
+                                    tempJarFile = strictJarFiles.get(tid);
+                                    if (tempJarFile == null) {
+                                        if (vData.index >= NUMBER_OF_CORES) {
+                                            vData.index = 0;
+                                        }
+                                        tempJarFile = jarFile[vData.index++];
+                                        strictJarFiles.put(tid, tempJarFile);
+                                    }
+                                }
+                                final Certificate[][] entryCerts = loadCertificates(tempJarFile, entry);
+                                if (ArrayUtils.isEmpty(entryCerts)) {
+                                    throw new PackageParserException(INSTALL_PARSE_FAILED_NO_CERTIFICATES,
+                                            "Package " + apkPath + " has no certificates at entry "
+                                            + entry.getName());
+                                }
+
+                                // make sure all entries use the same signing certs
+                                final Signature[] entrySigs = convertToSignatures(entryCerts);
+                                if (!Signature.areExactMatch(lastSigs, entrySigs)) {
+                                    throw new PackageParserException(
+                                            INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES,
+                                            "Package " + apkPath + " has mismatched certificates at entry "
+                                            + entry.getName());
+                                }
+                            } catch (GeneralSecurityException e) {
+                                synchronized (vData.objWaitAll) {
+                                    vData.exceptionFlag = INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING;
+                                    vData.exception = e;
+                                }
+                            } catch (PackageParserException e) {
+                                synchronized (vData.objWaitAll) {
+                                    vData.exceptionFlag = INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION;
+                                    vData.exception = e;
+                                }
+                            }
+                        }};
+                    synchronized (vData.objWaitAll) {
+                        if (vData.exceptionFlag == 0) {
+                            verificationExecutor.execute(verifyTask);
+                        }
                     }
-
-                    // make sure all entries use the same signing certs
-                    final Signature[] entrySigs = convertToSignatures(entryCerts);
-                    if (!Signature.areExactMatch(lastSigs, entrySigs)) {
-                        throw new PackageParserException(
-                                INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES,
-                                "Package " + apkPath + " has mismatched certificates at entry "
-                                        + entry.getName());
+                }
+                vData.wait = true;
+                verificationExecutor.shutdown();
+                while (vData.wait) {
+                    try {
+                        if (vData.exceptionFlag != 0 && !vData.shutDown) {
+                            Slog.w(TAG, "verifyV1 Exception " + vData.exceptionFlag);
+                            verificationExecutor.shutdownNow();
+                            vData.shutDown = true;
+                        }
+                        vData.wait = !verificationExecutor.awaitTermination(50,
+                                TimeUnit.MILLISECONDS);
+                    } catch (InterruptedException e) {
+                        Slog.w(TAG,"VerifyV1 interrupted while awaiting all threads done...");
                     }
                 }
+                if (vData.exceptionFlag != 0)
+                    throw new PackageParserException(vData.exceptionFlag,
+                            "Failed to collect certificates from " + apkPath, vData.exception);
             }
             return new PackageParser.SigningDetails(lastSigs, SignatureSchemeVersion.JAR);
         } catch (GeneralSecurityException e) {
@@ -232,8 +315,11 @@ private static PackageParser.SigningDetails verifyV1Signature(
             throw new PackageParserException(INSTALL_PARSE_FAILED_NO_CERTIFICATES,
                     "Failed to collect certificates from " + apkPath, e);
         } finally {
+            strictJarFiles.clear();
             Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
-            closeQuietly(jarFile);
+            for (int i = 0; i < objectNumber ; i++) {
+                closeQuietly(jarFile[i]);
+            }
         }
     }