@autorunify/capacitor-nrfmesh 0.0.1

package/Android-nRF-Mesh-Library/mesh/src/main/java/no/nordicsemi/android/mesh/AddressRange.java

@@ -0,0 +1,182 @@
+package no.nordicsemi.android.mesh;
+
+import com.google.gson.annotations.Expose;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+
+@SuppressWarnings("unused")
+public abstract class AddressRange extends Range {
+
+    @Expose
+    int lowAddress;
+
+    @Expose
+    int highAddress;
+
+    /**
+     * Returns the low address of the allocated group address
+     *
+     * @return low address
+     */
+    public abstract int getLowAddress();
+
+    /**
+     * Returns the high address of the allocated group range
+     *
+     * @return highAddress of the group range
+     */
+    public abstract int getHighAddress();
+
+    @Override
+    public int range() {
+        return highAddress - lowAddress;
+    }
+
+    @Override
+    public boolean overlaps(@NonNull final Range otherRange) {
+        if (otherRange instanceof AddressRange) {
+            final AddressRange otherAddressRange = (AddressRange) otherRange;
+            return overlaps(lowAddress, highAddress, otherAddressRange.getLowAddress(), otherAddressRange.getHighAddress());
+        }
+        return false;
+    }
+
+    /**
+     * Subtracts a range from a list of ranges
+     *
+     * @param ranges ranges to be subtracted
+     * @param other  {@link AllocatedGroupRange} range
+     * @return a resulting {@link AllocatedGroupRange} or null otherwise
+     */
+    @NonNull
+    public static List<AllocatedGroupRange> minus(@NonNull final List<AllocatedGroupRange> ranges, @NonNull final AllocatedGroupRange other) {
+        List<AllocatedGroupRange> results = new ArrayList<>();
+        for (AllocatedGroupRange range : ranges) {
+            results.addAll(range.minus(other));
+            results = mergeGroupRanges(results);
+        }
+        return results;
+    }
+
+    /**
+     * Deducts a range from another
+     *
+     * @param other right {@link AllocatedGroupRange}
+     * @return a resulting {@link AllocatedGroupRange} or null otherwise
+     */
+    List<AllocatedGroupRange> minus(final AllocatedGroupRange other) {
+        final List<AllocatedGroupRange> results = new ArrayList<>();
+        // Left:   |------------|                    |-----------|                 |---------|
+        //                  -                              -                            -
+        // Right:      |-----------------|   or                     |---|   or        |----|
+        //                  =                              =                            =
+        // Result: |---|                             |-----------|                 |--|
+        if (other.lowAddress > lowAddress) {
+            final AllocatedGroupRange leftSlice = new AllocatedGroupRange(lowAddress, (Math.min(highAddress, other.lowAddress - 1)));
+            results.add(leftSlice);
+        }
+
+        // Left:                |----------|             |-----------|                     |--------|
+        //                         -                          -                             -
+        // Right:      |----------------|           or       |----|          or     |---|
+        //                         =                          =                             =
+        // Result:                      |--|                      |--|                     |--------|
+        if (other.highAddress < highAddress) {
+            final AllocatedGroupRange rightSlice = new AllocatedGroupRange(Math.max(other.highAddress + 1, lowAddress), highAddress);
+            results.add(rightSlice);
+        }
+        return results;
+    }
+
+    /**
+     * Subtracts a range from a list of ranges
+     *
+     * @param ranges ranges to be subtracted
+     * @param other  {@link AllocatedUnicastRange} range
+     * @return a resulting {@link AllocatedUnicastRange} or null otherwise
+     */
+    @NonNull
+    public static List<AllocatedUnicastRange> minus(@NonNull final List<AllocatedUnicastRange> ranges, @NonNull final AllocatedUnicastRange other) {
+        List<AllocatedUnicastRange> results = new ArrayList<>();
+        for (AllocatedUnicastRange range : ranges) {
+            results.addAll(range.minus(other));
+            results = mergeUnicastRanges(results);
+        }
+        return results;
+    }
+
+    /**
+     * Deducts a range from another
+     *
+     * @param other right {@link AllocatedUnicastRange}
+     * @return a resulting {@link AllocatedUnicastRange} or null otherwise
+     */
+    List<AllocatedUnicastRange> minus(final AllocatedUnicastRange other) {
+        final List<AllocatedUnicastRange> results = new ArrayList<>();
+        // Left:   |------------|                    |-----------|                 |---------|
+        //                  -                              -                            -
+        // Right:      |-----------------|   or                     |---|   or        |----|
+        //                  =                              =                            =
+        // Result: |---|                             |-----------|                 |--|
+        if (other.lowAddress > lowAddress) {
+            final AllocatedUnicastRange leftSlice = new AllocatedUnicastRange(lowAddress, (Math.min(highAddress, other.lowAddress - 1)));
+            results.add(leftSlice);
+        }
+
+        // Left:                |----------|             |-----------|                     |--------|
+        //                         -                          -                             -
+        // Right:      |----------------|           or       |----|          or     |---|
+        //                         =                          =                             =
+        // Result:                      |--|                      |--|                     |--------|
+        if (other.highAddress < highAddress) {
+            final AllocatedUnicastRange rightSlice = new AllocatedUnicastRange(Math.max(other.highAddress + 1, lowAddress), highAddress);
+            results.add(rightSlice);
+        }
+        return results;
+    }
+
+    /**
+     * Checks if the address is in range.
+     *
+     * @param address address to be verified.
+     * @return true if the address in range or false otherwise.
+     */
+    public Boolean isInRange(int address) {
+        return address >= lowAddress && address <= highAddress;
+    }
+
+    /**
+     * Checks a given address is within any of the address range in a given list of address ranges.
+     *
+     * @param ranges  List of ranges.
+     * @param address address to be verified.
+     * @return true if the address is in range or false otherwise.
+     */
+    public static Boolean isAddressInAnyRanges(List<? extends AddressRange> ranges, int address) {
+        for (AddressRange range : ranges) {
+            if (range.isInRange(address)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
+    @Override
+    public boolean equals(final Object o) {
+        if(this == o)
+            return true;
+        final AddressRange range = (AddressRange) o;
+        return lowAddress == range.lowAddress && highAddress == range.highAddress;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = lowAddress;
+        result = 31 * result + highAddress;
+        return result;
+    }
+}

package/Android-nRF-Mesh-Library/mesh/src/main/java/no/nordicsemi/android/mesh/AllocatedGroupRange.java

@@ -0,0 +1,116 @@
+package no.nordicsemi.android.mesh;
+
+import android.os.Parcel;
+
+import androidx.room.Ignore;
+import no.nordicsemi.android.mesh.utils.MeshAddress;
+
+
+/**
+ * Class definition for allocating group range for provisioners.
+ */
+@SuppressWarnings({"unused"})
+public class AllocatedGroupRange extends AddressRange {
+
+    @Override
+    public final int getLowerBound() {
+        return MeshAddress.START_GROUP_ADDRESS;
+    }
+
+    @Override
+    public final int getUpperBound() {
+        return MeshAddress.END_GROUP_ADDRESS;
+    }
+
+    /**
+     * Constructs {@link AllocatedGroupRange} for provisioner
+     *
+     * @param lowAddress  low address of group range
+     * @param highAddress high address of group range
+     */
+    public AllocatedGroupRange(final int lowAddress, final int highAddress) {
+        lowerBound = MeshAddress.START_GROUP_ADDRESS;
+        upperBound = MeshAddress.END_GROUP_ADDRESS;
+        if (!MeshAddress.isValidGroupAddress(lowAddress))
+            throw new IllegalArgumentException("Low address must range from 0xC000 to 0xFEFF");
+
+        if (!MeshAddress.isValidGroupAddress(highAddress))
+            throw new IllegalArgumentException("High address must range from 0xC000 to 0xFEFF");
+
+        /*if(lowAddress > highAddress)
+            throw new IllegalArgumentException("low address must be lower than the high address");*/
+
+        this.lowAddress = lowAddress;
+        this.highAddress = highAddress;
+    }
+
+    @Ignore
+    AllocatedGroupRange() {
+    }
+
+    protected AllocatedGroupRange(Parcel in) {
+        lowerBound = in.readInt();
+        upperBound = in.readInt();
+        highAddress = in.readInt();
+        lowAddress = in.readInt();
+    }
+
+    public static final Creator<AllocatedGroupRange> CREATOR = new Creator<AllocatedGroupRange>() {
+        @Override
+        public AllocatedGroupRange createFromParcel(Parcel in) {
+            return new AllocatedGroupRange(in);
+        }
+
+        @Override
+        public AllocatedGroupRange[] newArray(int size) {
+            return new AllocatedGroupRange[size];
+        }
+    };
+
+    @Override
+    public int getLowAddress() {
+        return lowAddress;
+    }
+
+    /**
+     * Sets the low address of the allocated group address
+     *
+     * @param lowAddress of the group range
+     */
+    public void setLowAddress(final int lowAddress) {
+        this.lowAddress = lowAddress;
+    }
+
+    @Override
+    public int getHighAddress() {
+        return highAddress;
+    }
+
+    /**
+     * Sets the high address of the group address
+     *
+     * @param highAddress of the group range
+     */
+    public void setHighAddress(final int highAddress) {
+        this.highAddress = highAddress;
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(final Parcel dest, final int flags) {
+        dest.writeInt(lowerBound);
+        dest.writeInt(upperBound);
+        dest.writeInt(highAddress);
+        dest.writeInt(lowAddress);
+    }
+
+    /*@NonNull
+    @Override
+    public AllocatedGroupRange clone() throws CloneNotSupportedException {
+        return (AllocatedGroupRange) super.clone();
+    }*/
+}

package/Android-nRF-Mesh-Library/mesh/src/main/java/no/nordicsemi/android/mesh/AllocatedGroupRangeDeserializer.java

@@ -0,0 +1,51 @@
+package no.nordicsemi.android.mesh;
+
+import no.nordicsemi.android.mesh.logger.MeshLogger;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+import no.nordicsemi.android.mesh.utils.MeshAddress;
+
+final class AllocatedGroupRangeDeserializer implements JsonSerializer<List<AllocatedGroupRange>>, JsonDeserializer<List<AllocatedGroupRange>> {
+    private static final String TAG = AllocatedGroupRangeDeserializer.class.getSimpleName();
+
+    @Override
+    public List<AllocatedGroupRange> deserialize(final JsonElement json, final Type typeOfT, final JsonDeserializationContext context) throws JsonParseException {
+        final List<AllocatedGroupRange> groupRanges = new ArrayList<>();
+        try {
+            final JsonArray jsonObject = json.getAsJsonArray();
+            for (int i = 0; i < jsonObject.size(); i++) {
+                final JsonObject unicastRangeJson = jsonObject.get(i).getAsJsonObject();
+                final int lowAddress = Integer.parseInt(unicastRangeJson.get("lowAddress").getAsString(), 16);
+                final int highAddress = Integer.parseInt(unicastRangeJson.get("highAddress").getAsString(), 16);
+                groupRanges.add(new AllocatedGroupRange(lowAddress, highAddress));
+            }
+        } catch (Exception ex) {
+            MeshLogger.error(TAG, "Error while de-serializing Allocated group range: " + ex.getMessage());
+        }
+        return groupRanges;
+    }
+
+    @Override
+    public JsonElement serialize(final List<AllocatedGroupRange> ranges, final Type typeOfSrc, final JsonSerializationContext context) {
+        final JsonArray jsonArray = new JsonArray();
+        for (AllocatedGroupRange range : ranges) {
+            final JsonObject rangeJson = new JsonObject();
+            rangeJson.addProperty("lowAddress", MeshAddress.formatAddress(range.getLowAddress(), false));
+            rangeJson.addProperty("highAddress", MeshAddress.formatAddress(range.getHighAddress(), false));
+            jsonArray.add(rangeJson);
+        }
+        return jsonArray;
+    }
+}

package/Android-nRF-Mesh-Library/mesh/src/main/java/no/nordicsemi/android/mesh/AllocatedSceneRange.java

@@ -0,0 +1,209 @@
+package no.nordicsemi.android.mesh;
+
+import android.os.Parcel;
+
+import com.google.gson.annotations.Expose;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.room.Ignore;
+
+/**
+ * Class definition for allocating group range for provisioners.
+ */
+@SuppressWarnings({"unused"})
+public class AllocatedSceneRange extends Range {
+
+    @Expose
+    private int firstScene;
+
+    @Expose
+    private int lastScene;
+
+    @Override
+    public final int getLowerBound() {
+        return lowerBound;
+    }
+
+    @Override
+    public final int getUpperBound() {
+        return upperBound;
+    }
+
+    public List<Range> minus(final Range left, final Range right) {
+        return null;
+    }
+
+    /**
+     * Constructs {@link AllocatedSceneRange} for provisioner
+     *
+     * @param firstScene high address of group range
+     * @param lastScene  low address of group range
+     */
+    public AllocatedSceneRange(final int firstScene, final int lastScene) {
+        lowerBound = 0x0001;
+        upperBound = 0xFFFF;
+        if (firstScene < lowerBound || firstScene > upperBound)
+            throw new IllegalArgumentException("firstScene value must range from 0x0000 to 0xFFFF");
+
+        if (lastScene < lowerBound || lastScene > upperBound)
+            throw new IllegalArgumentException("lastScene value must range from 0x0000 to 0xFFFF");
+
+        /*if (firstScene > lastScene)
+            throw new IllegalArgumentException("firstScene value must be lower than the lastScene value");*/
+
+        this.firstScene = firstScene;
+        this.lastScene = lastScene;
+    }
+
+    @Ignore
+    AllocatedSceneRange() {
+    }
+
+    protected AllocatedSceneRange(Parcel in) {
+        lowerBound = in.readInt();
+        upperBound = in.readInt();
+        firstScene = in.readInt();
+        lastScene = in.readInt();
+    }
+
+    public static final Creator<AllocatedSceneRange> CREATOR = new Creator<AllocatedSceneRange>() {
+        @Override
+        public AllocatedSceneRange createFromParcel(Parcel in) {
+            return new AllocatedSceneRange(in);
+        }
+
+        @Override
+        public AllocatedSceneRange[] newArray(int size) {
+            return new AllocatedSceneRange[size];
+        }
+    };
+
+    /**
+     * Returns the low address of the allocated group address
+     *
+     * @return low address
+     */
+    public int getLastScene() {
+        return lastScene;
+    }
+
+    /**
+     * Sets the low address of the allocated group address
+     *
+     * @param lastScene of the group range
+     */
+    public void setLastScene(final int lastScene) {
+        this.lastScene = lastScene;
+    }
+
+    /**
+     * Returns the high address of the allocated group range
+     *
+     * @return firstScene of the group range
+     */
+    public int getFirstScene() {
+        return firstScene;
+    }
+
+    /**
+     * Sets the high address of the group address
+     *
+     * @param firstScene of the group range
+     */
+    public void setFirstScene(final int firstScene) {
+        this.firstScene = firstScene;
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(final Parcel dest, final int flags) {
+        dest.writeInt(lowerBound);
+        dest.writeInt(upperBound);
+        dest.writeInt(firstScene);
+        dest.writeInt(lastScene);
+    }
+
+    @Override
+    public int range() {
+        return lastScene - firstScene;
+    }
+
+    @Override
+    public boolean overlaps(@NonNull final Range otherRange) {
+        if (otherRange instanceof AllocatedSceneRange) {
+            final AllocatedSceneRange otherSceneRange = (AllocatedSceneRange) otherRange;
+            return overlaps(firstScene, lastScene, otherSceneRange.getFirstScene(), otherSceneRange.getLastScene());
+        }
+        return false;
+    }
+
+    /**
+     * Subtracts a range from a list of ranges
+     *
+     * @param ranges ranges to be subtracted
+     * @param other  {@link AllocatedSceneRange} range
+     * @return a resulting {@link AllocatedSceneRange} or null otherwise
+     */
+    @NonNull
+    public static List<AllocatedSceneRange> minus(@NonNull final List<AllocatedSceneRange> ranges, @NonNull final AllocatedSceneRange other) {
+        List<AllocatedSceneRange> results = new ArrayList<>();
+        for (AllocatedSceneRange range : ranges) {
+            results.addAll(range.minus(other));
+            results = mergeSceneRanges(results);
+        }
+        /*ranges.clear();
+        ranges.addAll(results);*/
+        return results;
+    }
+
+    /**
+     * Deducts a range from another
+     *
+     * @param other right {@link AllocatedSceneRange}
+     * @return a resulting {@link AllocatedSceneRange} or null otherwise
+     */
+    private List<AllocatedSceneRange> minus(final AllocatedSceneRange other) {
+        final List<AllocatedSceneRange> results = new ArrayList<>();
+        // Left:   |------------|                    |-----------|                 |---------|
+        //                  -                              -                            -
+        // Right:      |-----------------|   or                     |---|   or        |----|
+        //                  =                              =                            =
+        // Result: |---|                             |-----------|                 |--|
+        if (other.firstScene > firstScene) {
+            final AllocatedSceneRange leftSlice = new AllocatedSceneRange(firstScene, (Math.min(lastScene, other.firstScene - 1)));
+            results.add(leftSlice);
+        }
+
+        // Left:                |----------|             |-----------|                     |--------|
+        //                         -                          -                             -
+        // Right:      |----------------|           or       |----|          or     |---|
+        //                         =                          =                             =
+        // Result:                      |--|                      |--|                     |--------|
+        if (other.lastScene < lastScene) {
+            final AllocatedSceneRange rightSlice = new AllocatedSceneRange(Math.max(other.lastScene + 1, firstScene), lastScene);
+            results.add(rightSlice);
+        }
+        return results;
+    }
+
+    @SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
+    @Override
+    public boolean equals(final Object o) {
+        final AllocatedSceneRange range = (AllocatedSceneRange) o;
+        return firstScene == range.firstScene && lastScene == range.lastScene;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = firstScene;
+        result = 31 * result + lastScene;
+        return result;
+    }
+}

package/Android-nRF-Mesh-Library/mesh/src/main/java/no/nordicsemi/android/mesh/AllocatedSceneRangeDeserializer.java

@@ -0,0 +1,50 @@
+package no.nordicsemi.android.mesh;
+
+import no.nordicsemi.android.mesh.logger.MeshLogger;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+final class AllocatedSceneRangeDeserializer implements JsonSerializer<List<AllocatedSceneRange>>, JsonDeserializer<List<AllocatedSceneRange>> {
+    private static final String TAG = AllocatedSceneRangeDeserializer.class.getSimpleName();
+
+    @Override
+    public List<AllocatedSceneRange> deserialize(final JsonElement json, final Type typeOfT, final JsonDeserializationContext context) throws JsonParseException {
+        final List<AllocatedSceneRange> sceneRanges = new ArrayList<>();
+        try {
+            final JsonArray jsonObject = json.getAsJsonArray();
+            for (int i = 0; i < jsonObject.size(); i++) {
+                final JsonObject unicastRangeJson = jsonObject.get(i).getAsJsonObject();
+                final int firstScene = Integer.parseInt(unicastRangeJson.get("firstScene").getAsString(), 16);
+                final int lastScene = Integer.parseInt(unicastRangeJson.get("lastScene").getAsString(), 16);
+                sceneRanges.add(new AllocatedSceneRange(firstScene, lastScene));
+            }
+        } catch (Exception ex) {
+            MeshLogger.error(TAG, "Error while de-serializing allocated scene range: " + ex.getMessage());
+        }
+        return sceneRanges;
+    }
+
+    @Override
+    public JsonElement serialize(final List<AllocatedSceneRange> ranges, final Type typeOfSrc, final JsonSerializationContext context) {
+        final JsonArray jsonArray = new JsonArray();
+        for(AllocatedSceneRange range :  ranges){
+            final JsonObject rangeJson = new JsonObject();
+            rangeJson.addProperty("firstScene", String.format(Locale.US, "%04X", range.getFirstScene()));
+            rangeJson.addProperty("lastScene", String.format(Locale.US, "%04X", range.getLastScene()));
+            jsonArray.add(rangeJson);
+        }
+        return jsonArray;
+    }
+}