Feat/v3

LearningMachine/app/build.gradle

@@ -1,22 +1,22 @@
 apply plugin: 'com.android.application'
 
 android {
-    compileSdkVersion 33
-    buildToolsVersion '30.0.3'
+    namespace "com.learningmachine.android.app"
+    compileSdkVersion 34
     dexOptions {
         javaMaxHeapSize "4g"
     }
     defaultConfig {
         applicationId "com.learningmachine.android.app"
-        minSdkVersion 19
-        targetSdkVersion 33
-        versionName "3.1.11"
+        minSdkVersion 31
+        targetSdkVersion 34
+        versionName "3.2.0"
         def buildNumber = System.getenv("BUILD_NUMBER")
         if (buildNumber != null) {
             versionCode buildNumber.toInteger()
             versionNameSuffix "-" + buildNumber
         } else {
-            versionCode 58
+            versionCode 61
         }
 
         testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'
@@ -28,6 +28,10 @@ android {
         targetCompatibility JavaVersion.VERSION_1_8
     }
 
+    testOptions {
+        unitTests.returnDefaultValues = true
+    }
+
     signingConfigs {
         LearningMachineRelease {
             keyAlias System.getenv("SIGNING_KEY_ALIAS")
@@ -102,8 +106,10 @@ android {
         }
     }
 
-    dataBinding {
-        enabled = true
+    buildFeatures {
+        dataBinding true
+        viewBinding true
+        buildConfig true
     }
 
     lintOptions {
@@ -140,7 +146,7 @@ final JODATIME_VERSION = '2.8.1'
 
 // These must be forced until everyone gets on the same page
 // ?: 18.0, Robolectric: 20.0
-final GUAVA_VERSION = '25.1-android'
+final GUAVA_VERSION = '27.0.1-android'
 // RxLifecycle: 3.0.1, Robolectric: 2.0.1
 final FINDBUGS_VERSION = '3.0.1'
 
@@ -203,6 +209,8 @@ dependencies {
 
     testImplementation "junit:junit:$JUNIT_VERSION"
     testImplementation "org.hamcrest:hamcrest:2.2"
+    testImplementation "net.javacrumbs.json-unit:json-unit:2.33.0"
+    testImplementation "org.json:json:20140107"
     testImplementation "org.mockito:mockito-core:$MOCKITO_VERSION"
     testImplementation "org.robolectric:robolectric:$ROBOLECTRIC_VERSION"
     testImplementation "org.robolectric:shadows-multidex:$ROBOLECTRIC_VERSION"

LearningMachine/app/src/main/AndroidManifest.xml

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.learningmachine.android.app">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

LearningMachine/app/src/main/assets/www/verify.html

@@ -23,12 +23,15 @@
 			}
 
 			loadJSON("./certificate.json", async function(certificateContentsString) {
-                var certificate = new Verifier.Certificate(certificateContentsString, { locale: 'auto' });
+                var certificate = new Verifier.Certificate(certificateContentsString, {
+                  locale: 'auto',
+                  didResolverUrl: 'https://dev.uniresolver.io/1.0/identifiers'
+                });
                 await certificate.init();
-                Android.notifyChainName(certificate.chain.name);
                 var verificationSteps = certificate.verificationSteps;
                 Android.notifyVerificationSteps(JSON.stringify(verificationSteps));
-                certificate.verify(statusCallback);
+                await certificate.verify(statusCallback);
+                Android.notifyChainName(certificate.signers[0].chain.name);
             });
 		</script>
     </body>

LearningMachine/app/src/main/java/com/learningmachine/android/app/LMConstants.java

@@ -20,4 +20,6 @@ public class LMConstants {
     public static final boolean SHOULD_PERFORM_OWNERSHIP_CHECK = false;
     public static final String PLAY_STORE_URL = "market://details?id=com.learningmachine.android.app";
     public static final String PLAY_STORE_EXTERNAL_URL = "https://play.google.com/store/apps/details?id=com.learningmachine.android.app";
+
+    public static final String DID_RESOLVER_URL = "https://dev.uniresolver.io/1.0/identifiers";
 }

LearningMachine/app/src/main/java/com/learningmachine/android/app/data/CertificateManager.java

@@ -19,6 +19,7 @@
 import com.learningmachine.android.app.data.webservice.CertificateService;
 import com.learningmachine.android.app.data.webservice.response.IssuerResponse;
 import com.learningmachine.android.app.util.FileUtils;
+import com.learningmachine.android.app.util.StringUtils;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -38,17 +39,19 @@ public class CertificateManager {
 
     private final Context mContext;
     private final CertificateStore mCertificateStore;
-    private final IssuerStore mIssuerStore;
     private final CertificateService mCertificateService;
     private final BitcoinManager mBitcoinManager;
     private final IssuerManager mIssuerManager;
 
-    public CertificateManager(Context context, CertificateStore certificateStore,
-                              IssuerStore issuerStore, CertificateService certificateService,
-                              BitcoinManager bitcoinManager, IssuerManager issuerManager) {
+    public CertificateManager(
+            Context context,
+            CertificateStore certificateStore,
+            CertificateService certificateService,
+            BitcoinManager bitcoinManager,
+            IssuerManager issuerManager
+    ) {
         mContext = context;
         mCertificateStore = certificateStore;
-        mIssuerStore = issuerStore;
         mCertificateService = certificateService;
         mBitcoinManager = bitcoinManager;
         mIssuerManager = issuerManager;
@@ -149,11 +152,8 @@ private Observable<String> handleCertificateResponse(ResponseBody responseBody)
             String certUid = blockCert.getCertUid();
             FileUtils.saveCertificate(mContext, buffer, certUid);
 
-            return mIssuerManager.fetchIssuer(blockCert.getIssuerId()).map(issuer -> {
-                String recipientPublicKey = blockCert.getRecipientPublicKey();
-                mIssuerStore.saveIssuerResponse(issuer, recipientPublicKey);
-                return certUid;
-            });
+            saveIssuer(blockCert);
+            return Observable.just(certUid);
         } catch (JsonSyntaxException e) {
             Timber.w(e, "Certificate failed to parse");
             return Observable.error(e);
@@ -210,15 +210,21 @@ private Observable<String> handleCertificateInputStream(InputStream certInputStr
         String certUid = blockCert.getCertUid();
         FileUtils.renameCertificateFile(mContext, tempFilename, certUid);
 
-        return mIssuerManager.fetchIssuer(blockCert.getIssuerId()).map(issuer -> {
-            String recipientPublicKey = blockCert.getRecipientPublicKey();
-            mIssuerStore.saveIssuerResponse(issuer, recipientPublicKey);
-            return certUid;
-        });
+        saveIssuer(blockCert);
+        return Observable.just(certUid);
+    }
+
+    private void saveIssuer(BlockCert blockCert) {
+        mIssuerManager.fetchAndSaveIssuerOf(blockCert)
+            .subscribe(issuerUuid -> updateBlockCertIssuerUuid(blockCert.getCertUid(), issuerUuid));
     }
 
     private void saveBlockCert(BlockCert blockCert) {
         Timber.i("Saving certificate " + blockCert.getCertName());
         mCertificateStore.saveBlockchainCertificate(blockCert);
     }
+
+    private void updateBlockCertIssuerUuid (String blockCertUuid, String issuerUuid) {
+        mCertificateStore.updateIssuerUuid(blockCertUuid, issuerUuid);
+    }
 }

LearningMachine/app/src/main/java/com/learningmachine/android/app/data/IssuerManager.java

@@ -2,6 +2,8 @@
 
 import android.content.Context;
 
+import com.learningmachine.android.app.LMConstants;
+import com.learningmachine.android.app.data.cert.BlockCert;
 import com.learningmachine.android.app.data.error.IssuerAnalyticsException;
 import com.learningmachine.android.app.data.model.IssuerRecord;
 import com.learningmachine.android.app.data.store.IssuerStore;
@@ -52,7 +54,20 @@ public Observable<List<IssuerRecord>> getIssuers() {
         return Observable.just(mIssuerStore.loadIssuers());
     }
 
+    public Observable<String> fetchAndSaveIssuerOf (BlockCert blockCert) {
+        return fetchIssuer(blockCert.getIssuerId()).<String>flatMap(issuer -> {
+            String recipientPublicKey = blockCert.getRecipientPublicKey();
+            return Observable.just(saveIssuer(issuer, recipientPublicKey));
+        });
+    }
+
     public Observable<IssuerResponse> fetchIssuer(String url) {
+        if (StringUtils.isDid(url)) {
+            final String didUri = url;
+            final String didResolveUrl = LMConstants.DID_RESOLVER_URL + "/" + didUri;
+            return mIssuerService.getIssuerDID(didResolveUrl)
+                    .flatMap(didDocument -> mIssuerService.getIssuer(didDocument.getIssuerProfileUrl()));
+        }
         return mIssuerService.getIssuer(url);
     }
 

LearningMachine/app/src/main/java/com/learningmachine/android/app/data/cert/BlockCert.java

@@ -18,6 +18,8 @@ public interface BlockCert {
     String getMetadata();
     String getReceiptHash();
     String getExpirationDate();
+    abstract String getDisplayHtml();
+    abstract String version();
 
     /**
      * @return The portion of the certificate whose hash needs to be compared against the

LearningMachine/app/src/main/java/com/learningmachine/android/app/data/cert/BlockCertAdapter.java

@@ -3,15 +3,21 @@
 import com.google.gson.JsonDeserializationContext;
 import com.google.gson.JsonDeserializer;
 import com.google.gson.JsonElement;
+import com.google.gson.JsonArray;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParseException;
 import com.google.gson.JsonSerializationContext;
 import com.google.gson.JsonSerializer;
 import com.learningmachine.android.app.data.cert.v11.BlockCertV11;
 import com.learningmachine.android.app.data.cert.v12.BlockCertV12;
 import com.learningmachine.android.app.data.cert.v20.BlockCertV20;
+import com.learningmachine.android.app.data.cert.v30.BlockCertV30;
 
 import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.regex.*;
+
+import timber.log.Timber;
 
 public class BlockCertAdapter implements JsonSerializer<BlockCert>, JsonDeserializer<BlockCert> {
     @Override
@@ -28,47 +34,95 @@ public JsonElement serialize(BlockCert src, Type typeOfSrc, JsonSerializationCon
     public BlockCert deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
         BlockCert blockCert = null;
         JsonObject jsonObject = json.getAsJsonObject();
-        if (isV20(jsonObject)) {
-            blockCert = context.deserialize(json, BlockCertV20.class);
-            jsonObject.remove("signature");
-            blockCert.setDocumentNode(jsonObject);
-        } else if (isV12(jsonObject)) {
-            blockCert = context.deserialize(json, BlockCertV12.class);
-            blockCert.setDocumentNode(jsonObject.getAsJsonObject("document"));
-        } else if (isV11(jsonObject)) {
-            blockCert = context.deserialize(json, BlockCertV11.class);
+        blockCert = context.deserialize(json, getAdapterClass(jsonObject));
+        if (blockCert != null) {
             blockCert.setDocumentNode(jsonObject);
         }
         return blockCert;
     }
 
-    private boolean isV11(JsonObject jsonObject) {
-        if (jsonObject.get("certificate") != null
-                && jsonObject.get("assertion") != null
-                && jsonObject.get("verify") != null
-                && jsonObject.get("recipient") != null
-                && jsonObject.get("signature") != null
-                && jsonObject.get("extension") != null) {
-            return true;
+    private Class<?> getAdapterClass (JsonObject jsonObject) {
+        final String version = getBlockcertsVersion(jsonObject);
+        switch (version) {
+            case "v1.1":
+                return BlockCertV11.class;
+
+            case "v1":
+            case "v1.2":
+                return BlockCertV12.class;
+
+            case "v2":
+            case "v2.0":
+            case "v2.1":
+                return BlockCertV20.class;
+
+            case "v3":
+            case "v3.0":
+            case "v3.1":
+                return BlockCertV30.class;
+
+            default:
+                Timber.e(String.format("Unrecognized blockcerts version: %s", version));
+                return null;
         }
-        return false;
     }
 
-    private boolean isV12(JsonObject jsonObject) {
-        if (jsonObject.get("@context") != null
-                && jsonObject.get("type") != null
-                && jsonObject.get("document") != null
-                && jsonObject.get("receipt") != null) {
-            return true;
+    private String getBlockcertsVersion (JsonObject jsonObject) {
+        if (jsonObject.get("@context") == null && isV11(jsonObject)) {
+            return "v1.1";
         }
-        return false;
+        ArrayList contextArray = new ArrayList<String>();
+        final JsonElement context = jsonObject.get("@context");
+        if (context.isJsonArray()) {
+            final JsonArray contextObjectAsArray = jsonObject.getAsJsonArray("@context");
+            getStringsFromContextArray(contextObjectAsArray, contextArray);
+        } else {
+            contextArray.add(context.toString());
+        }
+
+        final String blockcertsContextUrl = filterBlockcertsContext(contextArray);
+        if (blockcertsContextUrl != "") {
+            final String version = getVersionNumber(blockcertsContextUrl);
+            if (version.startsWith("v")) {
+                return version;
+            }
+            return "v" + version;
+        }
+        return "invalid blockcerts version";
+    }
+
+    private void getStringsFromContextArray (JsonArray array, ArrayList targetArray) {
+        for (int i = 0; i < array.size(); i++) {
+            if (!array.get(i).isJsonObject()) {
+                targetArray.add(array.get(i).toString());
+            }
+        }
+    }
+
+    private String filterBlockcertsContext(ArrayList<String> contextArray) {
+        Object[] result = contextArray.stream().filter(s -> s.contains("blockcerts")).toArray();
+        if (result.length != 0) {
+            return result[0].toString();
+        }
+        return "";
     }
 
-    private boolean isV20(JsonObject jsonObject) {
-        if (jsonObject.get("type") != null
-                && jsonObject.get("badge") != null
+    private String getVersionNumber (String blockcertsContextUrl) {
+        Pattern versionRegexPattern = Pattern.compile("/(v?\\d{1}.?\\d?\\b)");
+        Matcher matcher = versionRegexPattern.matcher(blockcertsContextUrl);
+        if (matcher.find()) {
+            return matcher.group(1);
+        }
+        return "";
+    }
+
+    private boolean isV11(JsonObject jsonObject) {
+        if (jsonObject.get("certificate") != null
+                && jsonObject.get("assertion") != null
+                && jsonObject.get("verify") != null
+                && jsonObject.get("recipient") != null
                 && jsonObject.get("signature") != null
-                && jsonObject.get("recipient") != null) {
+                && jsonObject.get("@context") == null) {
             return true;
         }
         return false;