Remove deprecated DexFile api

Author: vmutafov

test-app/app/src/main/assets/app/tests/testsForRuntimeBindingGenerator.js

@@ -49,29 +49,6 @@ describe("Tests for runtime binding generator", function () {
 		expect(isInstanceOf).toEqual(true);
 	});
 
-	it("When_implementing_interface_and_its_implemented_interfaces", function() {
-    	var impl = new com.tns.tests.MyDerivedPublicInterface({
-    		methodOfMyDerivedPublicInterface: function(input) {
-  			    return "Le java " + input;
-    		},
-    		methodOfMyPublicInterface: function(input) {
-    		    return "Le java " + input;
-    		}
-    	});
-
-    	try {
-    		var C = java.lang.Class.forName("com.tns.gen.com.tns.tests.MyDerivedPublicInterface");
-    		expect(C).not.toBe(null);
-
-    		var expected = "Le java test derived method";
-    		var actual = impl.methodOfMyPublicInterface("test derived method");
-    		expect(actual).toBe(expected);
-    	} catch (e) {
-    		//fail("class was not found");
-    		expect(true).toBe(false);
-    	}
-    });
-
 	it("When_generating_a_class_that_implements_interfaces_javascript", function() {
 
 	    __log("TEST: When_generating_a_class_that_implements_interfaces_javascript");

test-app/runtime/src/main/java/com/tns/ClassResolver.java

@@ -1,15 +1,17 @@
 package com.tns;
 
+import com.tns.system.classes.loading.ClassStorageService;
+
 import java.io.IOException;
 
 class ClassResolver {
-    private final Runtime runtime;
+    private final ClassStorageService classStorageService;
 
-    public ClassResolver(Runtime runtime) {
-        this.runtime = runtime;
+    ClassResolver(ClassStorageService classStorageService) {
+        this.classStorageService = classStorageService;
     }
 
-    public Class<?> resolveClass(String baseClassName, String fullClassName, DexFactory dexFactory, String[] methodOverrides, String[] implementedInterfaces, boolean isInterface) throws ClassNotFoundException, IOException {
+    Class<?> resolveClass(String baseClassName, String fullClassName, DexFactory dexFactory, String[] methodOverrides, String[] implementedInterfaces, boolean isInterface) throws ClassNotFoundException, IOException {
         String canonicalClassName = fullClassName.replace('/', '.');
         String canonicalBaseClassName = baseClassName.replace('/', '.');
         String name = "";
@@ -24,7 +26,7 @@ public Class<?> resolveClass(String baseClassName, String fullClassName, DexFact
         }
 
         if (clazz == null) {
-            clazz = Runtime.getClassForName(className);
+            clazz = classStorageService.retrieveClass(className);
         }
 
         return clazz;

test-app/runtime/src/main/java/com/tns/DexFactory.java

@@ -2,6 +2,12 @@
 
 import android.util.Log;
 
+import com.tns.bindings.AnnotationDescriptor;
+import com.tns.bindings.ProxyGenerator;
+import com.tns.bindings.desc.ClassDescriptor;
+import com.tns.bindings.desc.reflection.ClassInfo;
+import com.tns.system.classes.loading.ClassStorageService;
+
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
@@ -12,18 +18,11 @@
 import java.io.InputStreamReader;
 import java.io.InvalidClassException;
 import java.io.OutputStreamWriter;
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.List;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
 
-import com.tns.bindings.AnnotationDescriptor;
-import com.tns.bindings.ProxyGenerator;
-import com.tns.bindings.desc.ClassDescriptor;
-import com.tns.bindings.desc.reflection.ClassInfo;
-
 import dalvik.system.DexClassLoader;
 
 public class DexFactory {
@@ -34,11 +33,12 @@ public class DexFactory {
     private final File odexDir;
     private final String dexThumb;
     private final ClassLoader classLoader;
+    private final ClassStorageService classStorageService;
 
     private ProxyGenerator proxyGenerator;
     private HashMap<String, Class<?>> injectedDexClasses = new HashMap<String, Class<?>>();
 
-    public DexFactory(Logger logger, ClassLoader classLoader, File dexBaseDir, String dexThumb) {
+    DexFactory(Logger logger, ClassLoader classLoader, File dexBaseDir, String dexThumb, ClassStorageService classStorageService) {
         this.logger = logger;
         this.classLoader = classLoader;
         this.dexDir = dexBaseDir;
@@ -58,6 +58,7 @@ public DexFactory(Logger logger, ClassLoader classLoader, File dexBaseDir, Strin
 
         this.updateDexThumbAndPurgeCache();
         this.proxyGenerator.setProxyThumb(this.dexThumb);
+        this.classStorageService = classStorageService;
     }
 
     static long totalGenTime = 0;
@@ -154,36 +155,18 @@ public Class<?> resolveClass(String baseClassName, String name, String className
             out.closeEntry();
             out.close();
         }
-        //
 
-        Class<?> result = null;
-        try {
-            // use DexFile instead of DexClassLoader to allow class loading
-            // within the default class loader
-            // Note: According to the official documentation, DexFile should not
-            // be directly used.
-            // However, this is the only viable way to get our dynamic classes
-            // loaded within the system class loader
+        Class<?> result;
 
-            if (isInterface) {
-                @SuppressWarnings("deprecation")
-                dalvik.system.DexFile df = dalvik.system.DexFile.loadDex(jarFilePath, new File(this.odexDir, fullClassName).getAbsolutePath(), 0);
-                result = df.loadClass(fullClassName, classLoader);
-            } else {
-                @SuppressWarnings("deprecation")
-                dalvik.system.DexFile df = dalvik.system.DexFile.loadDex(jarFilePath, new File(this.odexDir, desiredDexClassName).getAbsolutePath(), 0);
-                result = df.loadClass(desiredDexClassName, classLoader);
-            }
-        } catch (IOException e) {
-            Log.w("JS", String.format("Error resolving class %s: %s. Fall back to DexClassLoader."));
-            if (com.tns.Runtime.isDebuggable()) {
-                e.printStackTrace();
-            }
-            // fall back to DexClassLoader
+        if (isInterface) {
             DexClassLoader dexClassLoader = new DexClassLoader(jarFilePath, this.odexDir.getAbsolutePath(), null, classLoader);
             result = dexClassLoader.loadClass(fullClassName);
+        } else {
+            DexClassLoader dexClassLoader = new DexClassLoader(jarFilePath, this.odexDir.getAbsolutePath(), null, classLoader);
+            result = dexClassLoader.loadClass(desiredDexClassName);
         }
 
+        classStorageService.storeClass(result.getName(), result);
         this.injectedDexClasses.put(originalFullClassName, result);
 
         return result;

test-app/runtime/src/main/java/com/tns/Runtime.java

@@ -1,36 +1,37 @@
 package com.tns;
 
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Message;
+import android.os.Process;
+
+import com.tns.bindings.ProxyGenerator;
+import com.tns.system.classes.caching.impl.ClassCacheImpl;
+import com.tns.system.classes.loading.ClassStorageService;
+import com.tns.system.classes.loading.impl.ClassStorageServiceImpl;
+import com.tns.system.classloaders.impl.ClassLoadersCollectionImpl;
+
 import java.io.File;
 import java.io.IOException;
-import java.nio.ByteBuffer;
 import java.lang.ref.WeakReference;
 import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Date;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import android.os.Handler;
-import android.os.HandlerThread;
-import android.os.Looper;
-import android.os.Message;
-import android.os.Process;
-import android.util.Log;
-import android.util.SparseArray;
-
-import com.tns.bindings.ProxyGenerator;
-
 public class Runtime {
     private native void initNativeScript(int runtimeId, String filesPath, String nativeLibDir, boolean verboseLoggingEnabled, boolean isDebuggable, String packageName,
                                          Object[] v8Options, String callingDir, int maxLogcatObjectSize, boolean forceLog);
@@ -94,10 +95,6 @@ public static void passSuppressedExceptionToJs(Throwable ex, String methodName)
 
     private boolean initialized;
 
-    private final static HashMap<String, Class<?>> classCache = new HashMap<String, Class<?>>();
-
-    private final static HashSet<ClassLoader> classLoaderCache = new HashSet<ClassLoader>();
-
     private final static String FAILED_CTOR_RESOLUTION_MSG = "Check the number and type of arguments.\n" +
             "Primitive types need to be manually wrapped in their respective Object wrappers.\n" +
             "If you are creating an instance of an inner class, make sure to always provide reference to the outer `this` as the first argument.";
@@ -181,6 +178,8 @@ public int compare(Method lhs, Method rhs) {
      */
     private Map<Integer, Handler> workerIdToHandler = new HashMap<>();
 
+    private static final ClassStorageService classStorageService = new ClassStorageServiceImpl(ClassCacheImpl.INSTANCE, ClassLoadersCollectionImpl.INSTANCE);
+
     public Runtime(ClassResolver classResolver, GcListener gcListener, StaticConfiguration config, DynamicConfiguration dynamicConfig, int runtimeId, int workerId, HashMap<Integer, Object> strongInstances, HashMap<Integer, WeakReference<Object>> weakInstances, NativeScriptHashMap<Object, Integer> strongJavaObjectToId, NativeScriptWeakHashMap<Object, Integer> weakJavaObjectToId) {
         this.classResolver = classResolver;
         this.gcListener = gcListener;
@@ -212,7 +211,7 @@ public Runtime(StaticConfiguration config, DynamicConfiguration dynamicConfigura
                     this.mainThreadHandler = dynamicConfiguration.mainThreadScheduler.getHandler();
                 }
 
-                classResolver = new ClassResolver(this);
+                classResolver = new ClassResolver(classStorageService);
                 currentRuntime.set(this);
 
                 runtimeCache.put(this.runtimeId, this);
@@ -236,7 +235,7 @@ public static Runtime getCurrentRuntime() {
 
     public static boolean isDebuggable() {
         Runtime runtime = com.tns.Runtime.getCurrentRuntime();
-        if(runtime != null) {
+        if (runtime != null) {
             return runtime.config.isDebuggable;
         } else {
             return false;
@@ -265,7 +264,7 @@ private static String getStackTraceOnly(String content) {
             lines = Arrays.copyOfRange(lines, 1, lines.length);
         }
         String result = "";
-        for (String line: lines) {
+        for (String line : lines) {
             result += line + "\n";
         }
         return result;
@@ -284,7 +283,7 @@ public static String getStackTraceErrorMessage(Throwable ex) {
                 content = baos.toString("US-ASCII");
                 if (ex instanceof NativeScriptException) {
                     content = getStackTraceOnly(content);
-                    content = ((NativeScriptException)ex).getIncomingStackTrace() + content;
+                    content = ((NativeScriptException) ex).getIncomingStackTrace() + content;
                 }
             } catch (java.io.UnsupportedEncodingException e) {
                 content = e.getMessage();
@@ -599,7 +598,7 @@ private void init(Logger logger, String appName, String nativeLibDir, File rootD
         try {
             this.logger = logger;
 
-            this.dexFactory = new DexFactory(logger, classLoader, dexDir, dexThumb);
+            this.dexFactory = new DexFactory(logger, classLoader, dexDir, dexThumb, classStorageService);
 
             if (logger.isEnabled()) {
                 logger.write("Initializing NativeScript JAVA");
@@ -784,25 +783,7 @@ private void createJSInstance(Object instance) {
 
     @RuntimeCallable
     private static String[] getTypeMetadata(String className, int index) throws ClassNotFoundException {
-        Class<?> clazz = classCache.get(className);
-
-        if (clazz == null) {
-            for (ClassLoader classLoader : classLoaderCache) {
-                try {
-                    clazz = classLoader.loadClass(className);
-                    if (clazz != null) {
-                        classCache.put(className, clazz);
-                        break;
-                    }
-                } catch (ClassNotFoundException e1) {
-                    Log.w("JS", "Dynamically loading class " + className + " was unsuccessful. Will attempt to load class from alternative ClassLoader.");
-                }
-            }
-            if (clazz == null) {
-                clazz = Class.forName(className);
-                classCache.put(className, clazz);
-            }
-        }
+        Class<?> clazz = classStorageService.retrieveClass(className);
 
         String[] result = getTypeMetadata(clazz, index);
 
@@ -924,14 +905,7 @@ private void makeInstanceStrong(Object instance, int objectId) {
         strongJavaObjectToID.put(instance, key);
 
         Class<?> clazz = instance.getClass();
-        String className = clazz.getName();
-        if (!classCache.containsKey(className)) {
-            classCache.put(className, clazz);
-            ClassLoader clazzloader = clazz.getClassLoader();
-            if (!classLoaderCache.contains(clazzloader)) {
-                classLoaderCache.add(clazzloader);
-            }
-        }
+        classStorageService.storeClass(clazz.getName(), clazz);
 
         if (logger != null && logger.isEnabled()) {
             logger.write("MakeInstanceStrong (" + key + ", " + instance.getClass().toString() + ")");
@@ -1156,16 +1130,8 @@ private Object[] packageArgs(Object... args) {
         return packagedArgs;
     }
 
-    static Class<?> getClassForName(String className) throws ClassNotFoundException {
-        Class<?> clazz = classCache.get(className);
-        if (clazz == null) {
-            clazz = Class.forName(className);
-            if (clazz != null) {
-                classCache.put(className, clazz);
-            }
-        }
-
-        return clazz;
+    static Class<?> getClassForName(String className) {
+        return classStorageService.retrieveClass(className);
     }
 
     @RuntimeCallable
@@ -1191,7 +1157,8 @@ private String resolveMethodOverload(String className, String methodName, Object
             logger.write("resolveMethodOverload: Resolving method " + methodName + " on class " + className);
         }
 
-        Class<?> clazz = getClassForName(className);
+        Class<?> clazz = classStorageService.retrieveClass(className);
+
 
         String res = MethodResolver.resolveMethodOverload(clazz, methodName, args);
         if (logger.isEnabled()) {
@@ -1306,8 +1273,14 @@ public void run() {
 
     @RuntimeCallable
     private static Class<?> getCachedClass(String className) {
-        Class<?> clazz = classCache.get(className);
-        return clazz;
+        Class<?> clazz;
+
+        try {
+            clazz = classStorageService.retrieveClass(className);
+            return clazz;
+        } catch (RuntimeException e){
+            return null;
+        }
     }
 
     @RuntimeCallable

test-app/runtime/src/main/java/com/tns/system/classes/caching/ClassCache.java

@@ -0,0 +1,19 @@
+package com.tns.system.classes.caching;
+
+public interface ClassCache {
+
+    /**
+     * Get cached class by given key
+     * @param lookupKey key used for getting the class
+     * @return cached class
+     */
+    Class<?> getCachedClass(String lookupKey);
+
+    /**
+     * Adds a class to the cache
+     *
+     * @param lookupKey key used for getting the class at later point; must not be null or empty string; at most times it's probably best to be the class' name
+     * @param clazz     class to store in the cache
+     */
+    void addClass(String lookupKey, Class<?> clazz);
+}