@capgo/capacitor-updater 6.14.0 → 6.14.2

package/android/src/main/java/ee/forgr/capacitor_updater/CryptoCipherV2.java

@@ -38,293 +38,239 @@ import javax.crypto.spec.SecretKeySpec;
 
 public class CryptoCipherV2 {
 
-  public static byte[] decryptRSA(byte[] source, PublicKey publicKey)
-    throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
-    Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
-    cipher.init(Cipher.DECRYPT_MODE, publicKey);
-    byte[] decryptedBytes = cipher.doFinal(source);
-    return decryptedBytes;
-  }
-
-  public static byte[] decryptAES(byte[] cipherText, SecretKey key, byte[] iv) {
-    try {
-      IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
-      Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
-      SecretKeySpec keySpec = new SecretKeySpec(key.getEncoded(), "AES");
-      cipher.init(Cipher.DECRYPT_MODE, keySpec, ivParameterSpec);
-      return cipher.doFinal(cipherText);
-    } catch (Exception e) {
-      e.printStackTrace();
+    public static byte[] decryptRSA(byte[] source, PublicKey publicKey)
+        throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
+        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
+        cipher.init(Cipher.DECRYPT_MODE, publicKey);
+        byte[] decryptedBytes = cipher.doFinal(source);
+        return decryptedBytes;
     }
-    return null;
-  }
 
-  public static SecretKey byteToSessionKey(byte[] sessionKey) {
-    // rebuild key using SecretKeySpec
-    return new SecretKeySpec(sessionKey, 0, sessionKey.length, "AES");
-  }
+    public static byte[] decryptAES(byte[] cipherText, SecretKey key, byte[] iv) {
+        try {
+            IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
+            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+            SecretKeySpec keySpec = new SecretKeySpec(key.getEncoded(), "AES");
+            cipher.init(Cipher.DECRYPT_MODE, keySpec, ivParameterSpec);
+            return cipher.doFinal(cipherText);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
 
-  private static PublicKey readX509PublicKey(byte[] x509Bytes)
-    throws GeneralSecurityException {
-    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
-    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(x509Bytes);
-    try {
-      return keyFactory.generatePublic(keySpec);
-    } catch (InvalidKeySpecException e) {
-      throw new IllegalArgumentException("Unexpected key format!", e);
+    public static SecretKey byteToSessionKey(byte[] sessionKey) {
+        // rebuild key using SecretKeySpec
+        return new SecretKeySpec(sessionKey, 0, sessionKey.length, "AES");
     }
-  }
 
-  public static PublicKey stringToPublicKey(String public_key)
-    throws GeneralSecurityException {
-    String pkcs1Pem = public_key
-      .replaceAll("\\s+", "")
-      .replace("-----BEGINRSAPUBLICKEY-----", "")
-      .replace("-----ENDRSAPUBLICKEY-----", "");
+    private static PublicKey readX509PublicKey(byte[] x509Bytes) throws GeneralSecurityException {
+        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
+        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(x509Bytes);
+        try {
+            return keyFactory.generatePublic(keySpec);
+        } catch (InvalidKeySpecException e) {
+            throw new IllegalArgumentException("Unexpected key format!", e);
+        }
+    }
 
-    byte[] pkcs1EncodedBytes = Base64.decode(pkcs1Pem, Base64.DEFAULT);
-    return readPkcs1PublicKey(pkcs1EncodedBytes);
-  }
+    public static PublicKey stringToPublicKey(String public_key) throws GeneralSecurityException {
+        String pkcs1Pem = public_key
+            .replaceAll("\\s+", "")
+            .replace("-----BEGINRSAPUBLICKEY-----", "")
+            .replace("-----ENDRSAPUBLICKEY-----", "");
 
-  // since the public key is in pkcs1 format, we have to convert it to x509 format similar
-  // to what needs done with the private key converting to pkcs8 format
-  // so, the rest of the code below here is adapted from here https://stackoverflow.com/a/54246646
-  private static final int SEQUENCE_TAG = 0x30;
-  private static final int BIT_STRING_TAG = 0x03;
-  private static final byte[] NO_UNUSED_BITS = new byte[] { 0x00 };
-  private static final byte[] RSA_ALGORITHM_IDENTIFIER_SEQUENCE = {
-    (byte) 0x30,
-    (byte) 0x0d,
-    (byte) 0x06,
-    (byte) 0x09,
-    (byte) 0x2a,
-    (byte) 0x86,
-    (byte) 0x48,
-    (byte) 0x86,
-    (byte) 0xf7,
-    (byte) 0x0d,
-    (byte) 0x01,
-    (byte) 0x01,
-    (byte) 0x01,
-    (byte) 0x05,
-    (byte) 0x00,
-  };
+        byte[] pkcs1EncodedBytes = Base64.decode(pkcs1Pem, Base64.DEFAULT);
+        return readPkcs1PublicKey(pkcs1EncodedBytes);
+    }
 
-  private static PublicKey readPkcs1PublicKey(byte[] pkcs1Bytes)
-    throws NoSuchAlgorithmException, InvalidKeySpecException, GeneralSecurityException {
-    // convert the pkcs1 public key to an x509 favorable format
-    byte[] keyBitString = createDEREncoding(
-      BIT_STRING_TAG,
-      joinPublic(NO_UNUSED_BITS, pkcs1Bytes)
-    );
-    byte[] keyInfoValue = joinPublic(
-      RSA_ALGORITHM_IDENTIFIER_SEQUENCE,
-      keyBitString
-    );
-    byte[] keyInfoSequence = createDEREncoding(SEQUENCE_TAG, keyInfoValue);
-    return readX509PublicKey(keyInfoSequence);
-  }
+    // since the public key is in pkcs1 format, we have to convert it to x509 format similar
+    // to what needs done with the private key converting to pkcs8 format
+    // so, the rest of the code below here is adapted from here https://stackoverflow.com/a/54246646
+    private static final int SEQUENCE_TAG = 0x30;
+    private static final int BIT_STRING_TAG = 0x03;
+    private static final byte[] NO_UNUSED_BITS = new byte[] { 0x00 };
+    private static final byte[] RSA_ALGORITHM_IDENTIFIER_SEQUENCE = {
+        (byte) 0x30,
+        (byte) 0x0d,
+        (byte) 0x06,
+        (byte) 0x09,
+        (byte) 0x2a,
+        (byte) 0x86,
+        (byte) 0x48,
+        (byte) 0x86,
+        (byte) 0xf7,
+        (byte) 0x0d,
+        (byte) 0x01,
+        (byte) 0x01,
+        (byte) 0x01,
+        (byte) 0x05,
+        (byte) 0x00
+    };
 
-  private static byte[] joinPublic(byte[]... bas) {
-    int len = 0;
-    for (int i = 0; i < bas.length; i++) {
-      len += bas[i].length;
+    private static PublicKey readPkcs1PublicKey(byte[] pkcs1Bytes)
+        throws NoSuchAlgorithmException, InvalidKeySpecException, GeneralSecurityException {
+        // convert the pkcs1 public key to an x509 favorable format
+        byte[] keyBitString = createDEREncoding(BIT_STRING_TAG, joinPublic(NO_UNUSED_BITS, pkcs1Bytes));
+        byte[] keyInfoValue = joinPublic(RSA_ALGORITHM_IDENTIFIER_SEQUENCE, keyBitString);
+        byte[] keyInfoSequence = createDEREncoding(SEQUENCE_TAG, keyInfoValue);
+        return readX509PublicKey(keyInfoSequence);
     }
 
-    byte[] buf = new byte[len];
-    int off = 0;
-    for (int i = 0; i < bas.length; i++) {
-      System.arraycopy(bas[i], 0, buf, off, bas[i].length);
-      off += bas[i].length;
-    }
+    private static byte[] joinPublic(byte[]... bas) {
+        int len = 0;
+        for (int i = 0; i < bas.length; i++) {
+            len += bas[i].length;
+        }
 
-    return buf;
-  }
+        byte[] buf = new byte[len];
+        int off = 0;
+        for (int i = 0; i < bas.length; i++) {
+            System.arraycopy(bas[i], 0, buf, off, bas[i].length);
+            off += bas[i].length;
+        }
 
-  public static void decryptFile(
-    final File file,
-    final String publicKey,
-    final String ivSessionKey
-  ) throws IOException {
-    if (
-      publicKey.isEmpty() ||
-      ivSessionKey == null ||
-      ivSessionKey.isEmpty() ||
-      ivSessionKey.split(":").length != 2
-    ) {
-      Log.i(CapacitorUpdater.TAG, "Cannot found public key or sessionKey");
-      return;
-    }
-    if (!publicKey.startsWith("-----BEGIN RSA PUBLIC KEY-----")) {
-      Log.e(
-        CapacitorUpdater.TAG,
-        "The public key is not a valid RSA Public key"
-      );
-      return;
+        return buf;
     }
 
-    try {
-      String ivB64 = ivSessionKey.split(":")[0];
-      String sessionKeyB64 = ivSessionKey.split(":")[1];
-      byte[] iv = Base64.decode(ivB64.getBytes(), Base64.DEFAULT);
-      byte[] sessionKey = Base64.decode(
-        sessionKeyB64.getBytes(),
-        Base64.DEFAULT
-      );
-      PublicKey pKey = CryptoCipherV2.stringToPublicKey(publicKey);
-      byte[] decryptedSessionKey = CryptoCipherV2.decryptRSA(sessionKey, pKey);
+    public static void decryptFile(final File file, final String publicKey, final String ivSessionKey) throws IOException {
+        if (publicKey.isEmpty() || ivSessionKey == null || ivSessionKey.isEmpty() || ivSessionKey.split(":").length != 2) {
+            Log.i(CapacitorUpdater.TAG, "Cannot found public key or sessionKey");
+            return;
+        }
+        if (!publicKey.startsWith("-----BEGIN RSA PUBLIC KEY-----")) {
+            Log.e(CapacitorUpdater.TAG, "The public key is not a valid RSA Public key");
+            return;
+        }
 
-      SecretKey sKey = CryptoCipherV2.byteToSessionKey(decryptedSessionKey);
-      byte[] content = new byte[(int) file.length()];
+        try {
+            String ivB64 = ivSessionKey.split(":")[0];
+            String sessionKeyB64 = ivSessionKey.split(":")[1];
+            byte[] iv = Base64.decode(ivB64.getBytes(), Base64.DEFAULT);
+            byte[] sessionKey = Base64.decode(sessionKeyB64.getBytes(), Base64.DEFAULT);
+            PublicKey pKey = CryptoCipherV2.stringToPublicKey(publicKey);
+            byte[] decryptedSessionKey = CryptoCipherV2.decryptRSA(sessionKey, pKey);
 
-      try (
-        final FileInputStream fis = new FileInputStream(file);
-        final BufferedInputStream bis = new BufferedInputStream(fis);
-        final DataInputStream dis = new DataInputStream(bis)
-      ) {
-        dis.readFully(content);
-        dis.close();
-        byte[] decrypted = CryptoCipherV2.decryptAES(content, sKey, iv);
-        // write the decrypted string to the file
-        try (
-          final FileOutputStream fos = new FileOutputStream(
-            file.getAbsolutePath()
-          )
-        ) {
-          fos.write(decrypted);
-        }
-      }
-    } catch (GeneralSecurityException e) {
-      Log.i(CapacitorUpdater.TAG, "decryptFile fail");
-      e.printStackTrace();
-      throw new IOException("GeneralSecurityException");
-    }
-  }
+            SecretKey sKey = CryptoCipherV2.byteToSessionKey(decryptedSessionKey);
+            byte[] content = new byte[(int) file.length()];
 
-  public static String decryptChecksum(String checksum, String publicKey)
-    throws IOException {
-    if (publicKey.isEmpty()) {
-      Log.e(CapacitorUpdater.TAG, "The public key is empty");
-      return checksum;
-    }
-    try {
-      byte[] checksumBytes = Base64.decode(checksum, Base64.DEFAULT);
-      PublicKey pKey = CryptoCipherV2.stringToPublicKey(publicKey);
-      byte[] decryptedChecksum = CryptoCipherV2.decryptRSA(checksumBytes, pKey);
-      // return Base64.encodeToString(decryptedChecksum, Base64.DEFAULT);
-      String result = Base64.encodeToString(decryptedChecksum, Base64.DEFAULT);
-      return result.replaceAll("\\s", ""); // Remove all whitespace, including newlines
-    } catch (GeneralSecurityException e) {
-      Log.e(CapacitorUpdater.TAG, "decryptChecksum fail: " + e.getMessage());
-      throw new IOException("Decryption failed: " + e.getMessage());
+            try (
+                final FileInputStream fis = new FileInputStream(file);
+                final BufferedInputStream bis = new BufferedInputStream(fis);
+                final DataInputStream dis = new DataInputStream(bis)
+            ) {
+                dis.readFully(content);
+                dis.close();
+                byte[] decrypted = CryptoCipherV2.decryptAES(content, sKey, iv);
+                // write the decrypted string to the file
+                try (final FileOutputStream fos = new FileOutputStream(file.getAbsolutePath())) {
+                    fos.write(decrypted);
+                }
+            }
+        } catch (GeneralSecurityException e) {
+            Log.i(CapacitorUpdater.TAG, "decryptFile fail");
+            e.printStackTrace();
+            throw new IOException("GeneralSecurityException");
+        }
     }
-  }
 
-  public static String decryptChecksum(
-    String checksum,
-    String publicKey,
-    String version
-  ) throws IOException {
-    if (publicKey.isEmpty()) {
-      Log.e(CapacitorUpdater.TAG, "The public key is empty");
-      return checksum;
-    }
-    try {
-      byte[] checksumBytes = Base64.decode(checksum, Base64.DEFAULT);
-      PublicKey pKey = CryptoCipherV2.stringToPublicKey(publicKey);
-      byte[] decryptedChecksum = CryptoCipherV2.decryptRSA(checksumBytes, pKey);
-      // return Base64.encodeToString(decryptedChecksum, Base64.DEFAULT);
-      String result = Base64.encodeToString(decryptedChecksum, Base64.DEFAULT);
-      return result.replaceAll("\\s", ""); // Remove all whitespace, including newlines
-    } catch (GeneralSecurityException e) {
-      Log.e(CapacitorUpdater.TAG, "decryptChecksum fail: " + e.getMessage());
-      throw new IOException("Decryption failed: " + e.getMessage());
+    public static String decryptChecksum(String checksum, String publicKey) throws IOException {
+        if (publicKey.isEmpty()) {
+            Log.e(CapacitorUpdater.TAG, "The public key is empty");
+            return checksum;
+        }
+        try {
+            byte[] checksumBytes = Base64.decode(checksum, Base64.DEFAULT);
+            PublicKey pKey = CryptoCipherV2.stringToPublicKey(publicKey);
+            byte[] decryptedChecksum = CryptoCipherV2.decryptRSA(checksumBytes, pKey);
+            // return Base64.encodeToString(decryptedChecksum, Base64.DEFAULT);
+            String result = Base64.encodeToString(decryptedChecksum, Base64.DEFAULT);
+            return result.replaceAll("\\s", ""); // Remove all whitespace, including newlines
+        } catch (GeneralSecurityException e) {
+            Log.e(CapacitorUpdater.TAG, "decryptChecksum fail: " + e.getMessage());
+            throw new IOException("Decryption failed: " + e.getMessage());
+        }
     }
-  }
 
-  public static String calcChecksum(File file) {
-    final int BUFFER_SIZE = 1024 * 1024 * 5; // 5 MB buffer size
-    MessageDigest digest;
-    try {
-      digest = MessageDigest.getInstance("SHA-256");
-    } catch (java.security.NoSuchAlgorithmException e) {
-      System.err.println(
-        CapacitorUpdater.TAG + " SHA-256 algorithm not available"
-      );
-      return "";
+    public static String decryptChecksum(String checksum, String publicKey, String version) throws IOException {
+        if (publicKey.isEmpty()) {
+            Log.e(CapacitorUpdater.TAG, "The public key is empty");
+            return checksum;
+        }
+        try {
+            byte[] checksumBytes = Base64.decode(checksum, Base64.DEFAULT);
+            PublicKey pKey = CryptoCipherV2.stringToPublicKey(publicKey);
+            byte[] decryptedChecksum = CryptoCipherV2.decryptRSA(checksumBytes, pKey);
+            // return Base64.encodeToString(decryptedChecksum, Base64.DEFAULT);
+            String result = Base64.encodeToString(decryptedChecksum, Base64.DEFAULT);
+            return result.replaceAll("\\s", ""); // Remove all whitespace, including newlines
+        } catch (GeneralSecurityException e) {
+            Log.e(CapacitorUpdater.TAG, "decryptChecksum fail: " + e.getMessage());
+            throw new IOException("Decryption failed: " + e.getMessage());
+        }
     }
 
-    try (FileInputStream fis = new FileInputStream(file)) {
-      byte[] buffer = new byte[BUFFER_SIZE];
-      int length;
-      while ((length = fis.read(buffer)) != -1) {
-        digest.update(buffer, 0, length);
-      }
-      byte[] hash = digest.digest();
-      StringBuilder hexString = new StringBuilder();
-      for (byte b : hash) {
-        String hex = Integer.toHexString(0xff & b);
-        if (hex.length() == 1) hexString.append('0');
-        hexString.append(hex);
-      }
-      return hexString.toString();
-    } catch (IOException e) {
-      System.err.println(
-        CapacitorUpdater.TAG +
-        " Cannot calc checksum v2: " +
-        file.getPath() +
-        " " +
-        e.getMessage()
-      );
-      return "";
-    }
-  }
+    public static String calcChecksum(File file) {
+        final int BUFFER_SIZE = 1024 * 1024 * 5; // 5 MB buffer size
+        MessageDigest digest;
+        try {
+            digest = MessageDigest.getInstance("SHA-256");
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.err.println(CapacitorUpdater.TAG + " SHA-256 algorithm not available");
+            return "";
+        }
 
-  private static byte[] createDEREncoding(int tag, byte[] value) {
-    if (tag < 0 || tag >= 0xFF) {
-      throw new IllegalArgumentException(
-        "Currently only single byte tags supported"
-      );
+        try (FileInputStream fis = new FileInputStream(file)) {
+            byte[] buffer = new byte[BUFFER_SIZE];
+            int length;
+            while ((length = fis.read(buffer)) != -1) {
+                digest.update(buffer, 0, length);
+            }
+            byte[] hash = digest.digest();
+            StringBuilder hexString = new StringBuilder();
+            for (byte b : hash) {
+                String hex = Integer.toHexString(0xff & b);
+                if (hex.length() == 1) hexString.append('0');
+                hexString.append(hex);
+            }
+            return hexString.toString();
+        } catch (IOException e) {
+            System.err.println(CapacitorUpdater.TAG + " Cannot calc checksum v2: " + file.getPath() + " " + e.getMessage());
+            return "";
+        }
     }
 
-    byte[] lengthEncoding = createDERLengthEncoding(value.length);
+    private static byte[] createDEREncoding(int tag, byte[] value) {
+        if (tag < 0 || tag >= 0xFF) {
+            throw new IllegalArgumentException("Currently only single byte tags supported");
+        }
 
-    int size = 1 + lengthEncoding.length + value.length;
-    byte[] derEncodingBuf = new byte[size];
+        byte[] lengthEncoding = createDERLengthEncoding(value.length);
 
-    int off = 0;
-    derEncodingBuf[off++] = (byte) tag;
-    System.arraycopy(
-      lengthEncoding,
-      0,
-      derEncodingBuf,
-      off,
-      lengthEncoding.length
-    );
-    off += lengthEncoding.length;
-    System.arraycopy(value, 0, derEncodingBuf, off, value.length);
+        int size = 1 + lengthEncoding.length + value.length;
+        byte[] derEncodingBuf = new byte[size];
 
-    return derEncodingBuf;
-  }
+        int off = 0;
+        derEncodingBuf[off++] = (byte) tag;
+        System.arraycopy(lengthEncoding, 0, derEncodingBuf, off, lengthEncoding.length);
+        off += lengthEncoding.length;
+        System.arraycopy(value, 0, derEncodingBuf, off, value.length);
 
-  private static byte[] createDERLengthEncoding(int size) {
-    if (size <= 0x7F) {
-      // single byte length encoding
-      return new byte[] { (byte) size };
-    } else if (size <= 0xFF) {
-      // double byte length encoding
-      return new byte[] { (byte) 0x81, (byte) size };
-    } else if (size <= 0xFFFF) {
-      // triple byte length encoding
-      return new byte[] {
-        (byte) 0x82,
-        (byte) (size >> Byte.SIZE),
-        (byte) size,
-      };
+        return derEncodingBuf;
     }
 
-    throw new IllegalArgumentException(
-      "size too large, only up to 64KiB length encoding supported: " + size
-    );
-  }
+    private static byte[] createDERLengthEncoding(int size) {
+        if (size <= 0x7F) {
+            // single byte length encoding
+            return new byte[] { (byte) size };
+        } else if (size <= 0xFF) {
+            // double byte length encoding
+            return new byte[] { (byte) 0x81, (byte) size };
+        } else if (size <= 0xFFFF) {
+            // triple byte length encoding
+            return new byte[] { (byte) 0x82, (byte) (size >> Byte.SIZE), (byte) size };
+        }
+
+        throw new IllegalArgumentException("size too large, only up to 64KiB length encoding supported: " + size);
+    }
 }

package/android/src/main/java/ee/forgr/capacitor_updater/DataManager.java

@@ -4,25 +4,25 @@ import org.json.JSONArray;
 
 public class DataManager {
 
-  private static DataManager instance;
-  private JSONArray currentManifest;
+    private static DataManager instance;
+    private JSONArray currentManifest;
 
-  private DataManager() {}
+    private DataManager() {}
 
-  public static synchronized DataManager getInstance() {
-    if (instance == null) {
-      instance = new DataManager();
+    public static synchronized DataManager getInstance() {
+        if (instance == null) {
+            instance = new DataManager();
+        }
+        return instance;
     }
-    return instance;
-  }
 
-  public void setManifest(JSONArray manifest) {
-    this.currentManifest = manifest;
-  }
+    public void setManifest(JSONArray manifest) {
+        this.currentManifest = manifest;
+    }
 
-  public JSONArray getAndClearManifest() {
-    JSONArray manifest = this.currentManifest;
-    this.currentManifest = null;
-    return manifest;
-  }
+    public JSONArray getAndClearManifest() {
+        JSONArray manifest = this.currentManifest;
+        this.currentManifest = null;
+        return manifest;
+    }
 }

package/android/src/main/java/ee/forgr/capacitor_updater/DelayCondition.java

@@ -12,52 +12,48 @@ import java.util.Objects;
 
 public class DelayCondition {
 
-  @SerializedName("kind")
-  private DelayUntilNext kind;
-
-  @SerializedName("value")
-  private String value;
-
-  public DelayCondition(DelayUntilNext kind, String value) {
-    this.kind = kind;
-    this.value = value;
-  }
-
-  public DelayUntilNext getKind() {
-    return kind;
-  }
-
-  public void setKind(DelayUntilNext kind) {
-    this.kind = kind;
-  }
-
-  public String getValue() {
-    return value;
-  }
-
-  public void setValue(String value) {
-    this.value = value;
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (!(o instanceof DelayCondition that)) return false;
-    return (
-      getKind() == that.getKind() && Objects.equals(getValue(), that.getValue())
-    );
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(getKind(), getValue());
-  }
-
-  @NonNull
-  @Override
-  public String toString() {
-    return (
-      "DelayCondition{" + "kind=" + kind + ", value='" + value + '\'' + '}'
-    );
-  }
+    @SerializedName("kind")
+    private DelayUntilNext kind;
+
+    @SerializedName("value")
+    private String value;
+
+    public DelayCondition(DelayUntilNext kind, String value) {
+        this.kind = kind;
+        this.value = value;
+    }
+
+    public DelayUntilNext getKind() {
+        return kind;
+    }
+
+    public void setKind(DelayUntilNext kind) {
+        this.kind = kind;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof DelayCondition that)) return false;
+        return (getKind() == that.getKind() && Objects.equals(getValue(), that.getValue()));
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getKind(), getValue());
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        return ("DelayCondition{" + "kind=" + kind + ", value='" + value + '\'' + '}');
+    }
 }

package/android/src/main/java/ee/forgr/capacitor_updater/DelayUntilNext.java

@@ -7,8 +7,8 @@
 package ee.forgr.capacitor_updater;
 
 public enum DelayUntilNext {
-  background,
-  kill,
-  nativeVersion,
-  date,
+    background,
+    kill,
+    nativeVersion,
+    date
 }