rhodes 7.1.17 → 7.4.1

data/platform/android/Rhodes/src/com/rhomobile/rhodes/geolocation/GeoLocationImpl.java

@@ -78,7 +78,13 @@ public class GeoLocationImpl {
 			if (this.provider != null) {
 				this.manager.removeUpdates(this);
 			} else {
-				this.provider = this.manager.getProvider(this.providerName);
+				try {
+				    this.provider = this.manager.getProvider(this.providerName);
+				}
+				catch (Exception e) {
+				    Logger.E(TAG, e);
+				    this.provider = null;
+				}
 			}
 			if(this.provider != null) {
 				if (exMode) {

data/platform/android/Rhodes/src/com/rhomobile/rhodes/osfunctionality/AndroidFunctionality.java

@@ -28,6 +28,9 @@ package com.rhomobile.rhodes.osfunctionality;
 
 import android.content.Context;
 import android.webkit.WebView;
+import android.app.Activity;
+import android.content.Intent;
+import android.content.ComponentName;
 
 import android.app.Notification.Builder;
 
@@ -51,4 +54,7 @@ public interface AndroidFunctionality {
     void pauseWebView( WebView view, boolean doPause );
 
     Builder getNotificationBuilder( Context ctx, String channelID, String channelName );
-}
+    Builder getNotificationBuilderForService( Context ctx, String channelID, String channelName );
+    ComponentName startForegroundService(Activity activity, Intent service);
+
+}

data/platform/android/Rhodes/src/com/rhomobile/rhodes/osfunctionality/AndroidFunctionality01.java

@@ -36,6 +36,9 @@ import android.view.WindowManager;
 import android.webkit.WebSettings;
 import android.webkit.WebView;
 
+import android.app.Activity;
+import android.content.Intent;
+import android.content.ComponentName;
 import android.app.Notification.Builder;
 
 // Android 1.0
@@ -91,4 +94,14 @@ class AndroidFunctionality01 implements AndroidFunctionality {
     public Builder getNotificationBuilder( Context ctx, String channelID, String channelName ) {
         throw new UnsupportedOperationException();
     }
+
+    @Override
+    public Builder getNotificationBuilderForService( Context ctx, String channelID, String channelName ) {
+        throw new UnsupportedOperationException();
+    }
+
+	@Override
+	public ComponentName startForegroundService(Activity activity, Intent service) {
+		return activity.startService(service);
+	}
 }

data/platform/android/Rhodes/src/com/rhomobile/rhodes/osfunctionality/AndroidFunctionality11.java

@@ -56,4 +56,13 @@ class AndroidFunctionality11 extends AndroidFunctionality10 implements AndroidFu
 		builder.setPriority(PRIORITY_HIGH);
 		return builder;
 	}
+
+	@Override
+	public Builder getNotificationBuilderForService( Context ctx, String channelID, String channelName ) {
+		Builder builder = new android.app.Notification.Builder(ctx);
+		builder.setPriority(PRIORITY_HIGH);
+		return builder;
+	}
+
+	
 }

data/platform/android/Rhodes/src/com/rhomobile/rhodes/osfunctionality/AndroidFunctionality26.java

@@ -33,17 +33,23 @@ import android.app.NotificationManager;
 import com.rhomobile.rhodes.Logger;
 import android.os.Build.VERSION;
 
+import android.app.Activity;
+import android.content.Intent;
+import android.content.ComponentName;
 
+//Android 8.0
 @RequiresApi(26)
 class AndroidFunctionality26 extends AndroidFunctionality11 implements AndroidFunctionality {
 
     private static final String TAG = AndroidFunctionality26.class.getSimpleName();
     private static final int IMPORTANCE_HIGH = 0x00000004;
+    private static final int IMPORTANCE_NONE = 0x00000000;
+    private static final int IMPORTANCE_UNSPECIFIED = 0xfffffc18;
     private static final int PRIORITY_HIGH = 0x00000001;
 
-    @Override
-    public Builder getNotificationBuilder( Context ctx, String channelID, String channelName ) {
-
+    private Builder getNotificationBuilderEx( Context ctx, String channelID, String channelName, int priority, boolean showBadge )
+    {
+        Logger.D( TAG, "getNotificationBuilderEx() START" );
         Builder builder = null;
 
         try { 
@@ -61,10 +67,8 @@ class AndroidFunctionality26 extends AndroidFunctionality11 implements AndroidFu
             Object channel = getNCMethod.invoke(notificationManager,channelID);
 
             if (channel == null) {
+                Logger.D( TAG, "getNotificationBuilderEx() chanell==null" );
                 channel = ncCtor.newInstance( channelID, channelName, 4 );
-
-                enableVibrationMethod.invoke(channel,true);
-                setVibrationMethod.invoke(channel,new long[]{100, 200, 300, 400, 500, 400, 300, 200, 400});
               
                 createNCMethod.invoke(notificationManager,channel);
             }
@@ -77,16 +81,18 @@ class AndroidFunctionality26 extends AndroidFunctionality11 implements AndroidFu
                  (Builder)nbCtor.newInstance( ctx, channelID ) : 
                  (Builder)nbCtor.newInstance( ctx );
 
-            java.lang.reflect.Method setPriorityMethod = ncClass.getMethod("setPriority", Integer.class);
-
             if(android.os.Build.VERSION.SDK_INT >= 26)
             {
                 java.lang.reflect.Method setShowBadgeMethod = ncClass.getMethod("setShowBadge", boolean.class);
-                setShowBadgeMethod.invoke(channel, true);
-                setPriorityMethod.invoke(builder, IMPORTANCE_HIGH);
+                setShowBadgeMethod.invoke(channel, showBadge);        
+                java.lang.reflect.Method setPriorityMethod = ncClass.getMethod("setImportance", int.class);
+                setPriorityMethod.invoke(channel, priority);
+                //setPriorityMethod.invoke(channel, IMPORTANCE_HIGH);
+                //setPriorityMethod.invoke(channel, IMPORTANCE_UNSPECIFIED);
             }
             else
-            {
+            {		
+                java.lang.reflect.Method setPriorityMethod = Builder.class.getMethod("setPriority", int.class);
                 setPriorityMethod.invoke(builder, PRIORITY_HIGH);
                 //builder.setVisibility(android.app.Notification.VISIBILITY_PUBLIC);
             }
@@ -97,9 +103,51 @@ class AndroidFunctionality26 extends AndroidFunctionality11 implements AndroidFu
         }
 
         if ( null == builder ) {
+            Logger.D( TAG, "getNotificationBuilderEx() builder == null" );
             builder = super.getNotificationBuilder( ctx, channelID, channelName );
         }
+        Logger.D( TAG, "getNotificationBuilderEx() FINISH" );
 
         return builder;
-    }    
-}
+    }
+
+
+    @Override
+    public Builder getNotificationBuilder( Context ctx, String channelID, String channelName ) {
+        return getNotificationBuilderEx(ctx, channelID, channelName, IMPORTANCE_HIGH, true);
+    }
+
+    public Builder getNotificationBuilderForService( Context ctx, String channelID, String channelName ) {
+        return getNotificationBuilderEx(ctx, channelID, channelName, IMPORTANCE_UNSPECIFIED, false);
+    }
+
+    @Override
+	public ComponentName startForegroundService(Activity activity, Intent service) {
+        Logger.D( TAG, "startForegroundService() START" );
+        java.lang.reflect.Method methodStartForegroundService = null;
+        ComponentName resultOfInvoke = null;
+        try {
+            methodStartForegroundService = activity.getClass().getMethod("startForegroundService", Intent.class);
+        } catch( Exception e ) {
+            Logger.E( TAG, "Error: Activity class do not has startForegroundService() method !" );
+            Logger.E( TAG, e.toString() );
+        }
+        if (methodStartForegroundService!= null) {
+            try {
+                Logger.D( TAG, "invoke startForegroundService()" );
+                resultOfInvoke = (ComponentName)methodStartForegroundService.invoke(activity, service);
+            } catch( Exception e ) {
+                Logger.E( TAG, "Error: some error during invoke startForegroundService() method !" );
+                Logger.E( TAG, e.toString() );
+            }
+        }
+        else {
+            Logger.D( TAG, "use old startService()" );
+            resultOfInvoke = activity.startService(service);
+        }
+        Logger.D( TAG, "startForegroundService() FINISH" );
+        return resultOfInvoke;
+	}
+
+
+}

data/platform/android/Rhodes/src/com/rhomobile/rhodes/socket/RhoSocketImpl.java

@@ -27,6 +27,8 @@
 package com.rhomobile.rhodes.socket;
 
 import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
@@ -56,6 +58,9 @@ public class RhoSocketImpl extends SocketImpl {
 	private native void closeImpl(int sock);
 	private native Object getOptionImpl(int sock, int option);
 	private native void setOptionImpl(int sock, int option, Object value);
+
+	private FileInputStream is;
+	private FileOutputStream os;
 	
 	public RhoSocketImpl(int s, RhoSockAddr rem) {
 		Logger.D(TAG, "New socket wrapper. fd: " + s + ", host: " + rem.host + ", port: " + rem.port);
@@ -68,6 +73,9 @@ public class RhoSocketImpl extends SocketImpl {
 		sockfd = s;
 		remote = rem;
 		initImpl(sockfd);
+
+		is = new FileInputStream( this.fd );
+		os = new FileOutputStream( this.fd );
 	}
 	
 	@Override
@@ -124,14 +132,14 @@ public class RhoSocketImpl extends SocketImpl {
 	protected InputStream getInputStream() throws IOException {
 		Logger.T(TAG, "getInputStream");
 		// Ignore
-		return null;
+		return is;
 	}
 	
 	@Override
 	protected OutputStream getOutputStream() throws IOException {
 		Logger.T(TAG, "getOutputStream");
 		// Ignore
-		return null;
+		return os;
 	}
 	
 	@Override

data/platform/android/Rhodes/src/com/rhomobile/rhodes/socket/SSLImpl.java

@@ -40,10 +40,13 @@ import java.security.KeyStoreException;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 import java.security.UnrecoverableKeyException;
+import java.security.PrivateKey;
+import java.security.KeyStore.PasswordProtection;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateException;
 import java.security.cert.CertificateFactory;
 import java.security.cert.X509Certificate;
+import java.security.UnrecoverableEntryException;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -56,6 +59,7 @@ import javax.net.ssl.TrustManagerFactory;
 import javax.net.ssl.X509TrustManager;
 import android.net.http.X509TrustManagerExtensions;
 
+import android.os.Build;
 import android.util.Base64;
 
 import com.rhomobile.rhodes.Logger;
@@ -64,7 +68,12 @@ import com.rhomobile.rhodes.file.RhoFileApi;
 
 import java.util.StringTokenizer;
 import java.security.SecureRandom;
+import android.os.Looper;
+import com.rhomobile.rhodes.RhodesService;
 
+import org.conscrypt.BaseOpenSSLSocketAdapterFactory;
+import org.conscrypt.Conscrypt;
+import org.conscrypt.OpenSSLProvider;
 
 public class SSLImpl {
 	
@@ -82,7 +91,12 @@ public class SSLImpl {
     private int sockfd;
 
 	private InputStream is;
-	private OutputStream os;
+    private OutputStream os;
+
+    private static Certificate local_server_cert = null;
+    private static PrivateKey client_private_key = null;
+    private static Certificate[] client_cert_chain = null;
+
 	
 	public native RhoSockAddr getRemoteSockAddr(int sockfd);
 	
@@ -298,11 +312,117 @@ public class SSLImpl {
 
         return certs;
     }
-    
+
+    private static Certificate loadLocalServerCert(byte[] data)
+    {
+        InputStream certStream = new ByteArrayInputStream(data);
+        Certificate cert = null;
+
+        try {
+            CertificateFactory cf = CertificateFactory.getInstance("X.509");
+            cert = cf.generateCertificate(certStream);
+            certStream.close();
+        }
+        catch(Exception e)
+        {
+            Logger.E(TAG, e.getMessage());
+        }
+
+        return cert;
+    }
+
+    public static PrivateKey getClientPrivateKey()
+    {
+        return client_private_key;
+    }
+
+    public static Certificate[] getClientCertChain()
+    {
+        return client_cert_chain;
+    }
+
+    private static void loadLocalCientP12Bundle(byte[] data, String pwd)
+    {
+        if (client_private_key == null && client_cert_chain == null) {
+            try {
+                KeyStore clientKeystore = KeyStore.getInstance("pkcs12");
+                InputStream p12Stream = new ByteArrayInputStream(data);
+                clientKeystore.load(p12Stream, pwd.toCharArray());
+
+                KeyStore.ProtectionParameter protParam = new KeyStore.PasswordProtection(pwd.toCharArray());
+                KeyStore.PrivateKeyEntry pkEntry = (KeyStore.PrivateKeyEntry) clientKeystore.getEntry("taup12", protParam);
+                client_private_key = pkEntry.getPrivateKey();
+                client_cert_chain = pkEntry.getCertificateChain();
+
+                p12Stream.close();
+            } 
+            catch (Exception e) 
+            {
+                Logger.I(TAG, e.getMessage());
+                client_private_key = null;
+                client_cert_chain = null;
+            }
+
+        }
+    }
+
+    public static SSLSocketFactory getSecureClientFactory() throws NoSuchAlgorithmException, KeyManagementException, CertificateException, KeyStoreException, IOException, UnrecoverableKeyException
+    {
+        SSLContext context = SSLContext.getInstance("TLS");
+        
+        Logger.I(TAG, "Creating TrustManager for system certificates");        
+        TrustManagerFactory systemTmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+        systemTmf.init((KeyStore)null);        
+        X509TrustManager systemTrustManager = (X509TrustManager)systemTmf.getTrustManagers()[0];
+
+        KeyStore keystore = KeyStore.getInstance( KeyStore.getDefaultType() );
+        keystore.load(null);
+
+        if(local_server_cert != null)
+        {
+            keystore.setCertificateEntry("cert-alias-local", local_server_cert);
+        }
+
+        Logger.I(TAG, "Creating TrustManager for custom certificates");        
+        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+        tmf.init(keystore);        
+        X509TrustManager customTrustManager = (X509TrustManager)tmf.getTrustManagers()[0];
+                
+        KeyManagerFactory kmf = null;
+        KeyStore clientKeystore = null;
+
+        if(client_private_key != null && client_cert_chain != null)
+        {
+            if (clientKeystore == null)
+            {
+                clientKeystore = KeyStore.getInstance("pkcs12");
+                clientKeystore.load(null);
+            }
+                
+            KeyStore.PrivateKeyEntry pkEntry = new KeyStore.PrivateKeyEntry(client_private_key, client_cert_chain);
+            clientKeystore.setEntry("taup12", pkEntry, null);
+        }
+
+        if (clientKeystore != null) {
+            kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+            kmf.init(clientKeystore, null);
+        }
+       
+        context.init( 
+        		(kmf==null)?null:kmf.getKeyManagers(), 
+        		new TrustManager[] { new MySecureTrustManager( systemTrustManager, customTrustManager ) }, 
+        		new SecureRandom()
+        );
+        
+        Logger.I(TAG, "Secure SSL factory initialization completed");
+        
+        return (SSLSocketFactory)context.getSocketFactory();
+    }
+
     private static SSLSocketFactory getSecureFactory() throws NoSuchAlgorithmException, KeyManagementException, CertificateException, KeyStoreException, IOException, UnrecoverableKeyException {
         Logger.I(TAG, "Creating secure SSL factory");
         
-        SSLContext context = SSLContext.getInstance("TLS");
+        SSLContext context =  Build.VERSION.SDK_INT >= 30 ? SSLContext.getInstance("TLS", new OpenSSLProvider()) : SSLContext.getInstance("TLS");
         
         // First, load all system installed certificates
         Logger.I(TAG, "Creating TrustManager for system certificates");        
@@ -323,6 +443,10 @@ public class SSLImpl {
             }
         }
         
+        if(local_server_cert != null)
+        {
+            keystore.setCertificateEntry("cert-alias-local", local_server_cert);
+        }
                
         Logger.I(TAG, "Creating TrustManager for custom certificates");        
         TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
@@ -330,13 +454,13 @@ public class SSLImpl {
         X509TrustManager customTrustManager = (X509TrustManager)tmf.getTrustManagers()[0];
                 
         KeyManagerFactory kmf = null;
-        
+        KeyStore clientKeystore = null;
+
         if ( RhoConf.isExist("clientSSLCertificate")) {        	
         	String clientCertPath = RhoConf.getString("clientSSLCertificate");
         	
         	Logger.I(TAG, "clientSSLCertificate is " + clientCertPath );
 
-        	
         	if ( clientCertPath.length() > 0 ) {
                 Logger.I(TAG, "Creating KeyManager for client certificates");
         		kmf = KeyManagerFactory.getInstance( KeyManagerFactory.getDefaultAlgorithm() );
@@ -345,12 +469,28 @@ public class SSLImpl {
         		if (RhoConf.isExist("clientSSLCertificatePassword")) {
         			password = RhoConf.getString("clientSSLCertificatePassword");
         		}
-        	
-        		KeyStore clientKeystore = KeyStore.getInstance( "pkcs12" );
-        		clientKeystore.load( RhoFileApi.open(clientCertPath), password.toCharArray() );
-        		kmf.init(clientKeystore, password.toCharArray());
+            
+                clientKeystore = KeyStore.getInstance("pkcs12");
+                clientKeystore.load(RhoFileApi.open(clientCertPath), password.toCharArray() );   		
         	}
         }
+
+        if(client_private_key != null && client_cert_chain != null)
+        {
+            if (clientKeystore == null)
+            {
+                clientKeystore = KeyStore.getInstance("pkcs12");
+                clientKeystore.load(null);
+            }
+                
+            KeyStore.PrivateKeyEntry pkEntry = new KeyStore.PrivateKeyEntry(client_private_key, client_cert_chain);
+            clientKeystore.setEntry("taup12", pkEntry, null);
+        }
+
+        if (clientKeystore != null) {
+            kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+            kmf.init(clientKeystore, null);
+        }
        
         /* 
          * this really works only with first provided TrustManager, 
@@ -368,8 +508,12 @@ public class SSLImpl {
 
     }
     	
-	private static SSLSocketFactory getFactory(boolean verify) throws NoSuchAlgorithmException, KeyManagementException, CertificateException, KeyStoreException, IOException, UnrecoverableKeyException {
-		if (verify) {
+	public static SSLSocketFactory getFactory(boolean verify) throws NoSuchAlgorithmException, KeyManagementException, CertificateException, KeyStoreException, IOException, UnrecoverableKeyException {
+
+        if (Build.VERSION.SDK_INT >= 30)	    
+            Conscrypt.setUseEngineSocketByDefault(false);
+
+	    if (verify) {
 			//if ( secureFactory == null ) {
 				secureFactory = getSecureFactory();
 			//}
@@ -377,7 +521,7 @@ public class SSLImpl {
         }
 		
 		if (factory == null) {
-			SSLContext context = SSLContext.getInstance("TLS");
+			SSLContext context =  Build.VERSION.SDK_INT >= 30 ? SSLContext.getInstance("TLS", new OpenSSLProvider()) : SSLContext.getInstance("TLS");
 			TrustManager[] managers = {new MyTrustManager()};
 			context.init(null, managers, new SecureRandom());
             factory = context.getSocketFactory();
@@ -398,6 +542,91 @@ public class SSLImpl {
             return false;
         }
     }
+
+    public static void setRawCertificate(byte[] data)
+    {
+        local_server_cert = loadLocalServerCert(data);
+    }
+
+
+    public static void setP12(byte[] data, String p)
+    {
+        loadLocalCientP12Bundle(data, p);
+    }
+
+    private class SSLThreadIn extends Thread
+    {
+        private int n = 0;
+        private InputStream is = null;
+        private byte[] data = null;
+        private int size = 0;
+
+        public SSLThreadIn(InputStream i, byte[] d, int s)
+        {
+            this.is = i;
+            size = s;
+            data = d;
+        }
+
+        public void run() {
+            if(is != null)
+            {
+                try {
+                    n = is.read(data, 0, size);
+                } catch (IOException e) {
+
+                }
+            }
+        }
+
+        public int getReadenBytes()
+        {
+            return n;
+        }
+
+    }
+
+    private class SSLThreadShutdown extends Thread
+    {
+        private SSLSocket sock;
+
+        public SSLThreadShutdown(SSLSocket s)
+        {
+            sock = s;
+        }
+
+        public void run() {
+            try {
+                sock.close();
+            } catch (IOException e) {
+
+            }
+        }
+    }
+
+    private class SSLThreadOut extends Thread
+    {
+        private OutputStream os = null;
+        private byte[] data = null;
+
+        public SSLThreadOut(OutputStream o, byte[] d)
+        {
+            this.os = o;
+            data = d;
+        }
+
+        public void run() {
+            if(os != null)
+            {
+                try {
+                    os.write(data);
+                } catch (IOException e) {
+
+                }
+            }
+        }
+
+    } 
 	
 	public boolean connect(int fd, boolean sslVerifyPeer, String hostname ) {
 		try {
@@ -433,7 +662,14 @@ public class SSLImpl {
 			if (sock != null) {
                 synchronized (this) {
                     if (sock != null) {
-                        sock.close();
+
+                        if (RhodesService.isLocalHttpsServerEnable() && Looper.myLooper() == Looper.getMainLooper()) {
+                            SSLThreadShutdown shutdownThread = new SSLThreadShutdown(sock);                        
+                            shutdownThread.start();                     
+                            shutdownThread.join();
+                        } else
+                            sock.close();
+
                         sock = null;
                         os = null;
                         is = null;
@@ -458,7 +694,14 @@ public class SSLImpl {
                         aOs = os;
                 }
                 if (aOs != null) {
-                    aOs.write(data);
+                    
+                    if (RhodesService.isLocalHttpsServerEnable() && Looper.myLooper() == Looper.getMainLooper()) {
+                        SSLThreadOut ssl_out = new SSLThreadOut(os, data);
+                        ssl_out.start();
+                        ssl_out.join();
+                    } else
+                        aOs.write(data);
+
                     return true;
                 }
 			}
@@ -479,7 +722,16 @@ public class SSLImpl {
                 }
                 if (aIs != null) {
                     int size = data.length;
-                    int n = is.read(data, 0, size);
+                    int n = 0;
+
+                    if (RhodesService.isLocalHttpsServerEnable() && Looper.myLooper() == Looper.getMainLooper()) {
+                        SSLThreadIn ssl_in = new SSLThreadIn(is, data, size);
+                        ssl_in.start();
+                        ssl_in.join();
+                        n = ssl_in.getReadenBytes();
+                    } else
+                        n = is.read(data, 0, size);
+
                     return n;
                 }
 			}
@@ -492,4 +744,4 @@ public class SSLImpl {
 
 
 
-}
+}