@autorunify/capacitor-nrfmesh 0.0.1

package/Android-nRF-Mesh-Library/app/src/main/java/no/nordicsemi/android/nrfmesh/utils/NetworkExportUtils.java

@@ -0,0 +1,171 @@
+package no.nordicsemi.android.nrfmesh.utils;
+
+import android.os.AsyncTask;
+import android.util.Log;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.OutputStream;
+
+import androidx.annotation.NonNull;
+import no.nordicsemi.android.mesh.MeshManagerApi;
+
+public class NetworkExportUtils {
+
+    public interface NetworkExportCallbacks {
+
+        void onNetworkExported();
+
+        void onNetworkExportFailed(final String error);
+    }
+
+    /**
+     * Creates an AsyncTask to export the network
+     *
+     * @param meshManagerApi Mesh manager api
+     * @param outputStream   OutputStream obtained from the content resolver
+     * @param callbacks      {@link NetworkExportCallbacks}
+     */
+    public static void exportMeshNetwork(@NonNull final MeshManagerApi meshManagerApi,
+                                         @NonNull final OutputStream outputStream,
+                                         @NonNull NetworkExportCallbacks callbacks) {
+        final NetworkExportAsyncTask task = new NetworkExportAsyncTask(meshManagerApi, outputStream, callbacks);
+        task.execute();
+    }
+
+    /**
+     * Creates an AsyncTask to import the a mesh network
+     *
+     * @param meshManagerApi Mesh manager api
+     * @param path           OutputStream obtained from the content resolver
+     * @param callbacks      {@link NetworkExportCallbacks}
+     */
+    public static void exportMeshNetwork(@NonNull final MeshManagerApi meshManagerApi,
+                                         @NonNull final String path,
+                                         @NonNull final String fileName,
+                                         @NonNull NetworkExportCallbacks callbacks) {
+        final NetworkExportAsyncTask2 task = new NetworkExportAsyncTask2(meshManagerApi, path, fileName, callbacks);
+        task.execute();
+    }
+
+    private static class NetworkExportAsyncTask extends AsyncTask<Void, Void, Boolean> {
+
+        private static final String TAG = NetworkExportUtils.NetworkExportAsyncTask.class.getSimpleName();
+        private final MeshManagerApi meshManagerApi;
+        private final OutputStream outputStream;
+        private final NetworkExportCallbacks callbacks;
+        private String error;
+
+        /**
+         * Creates an AsyncTask to import the a mesh network
+         *
+         * @param meshManagerApi Mesh manager api
+         */
+        NetworkExportAsyncTask(@NonNull final MeshManagerApi meshManagerApi,
+                               @NonNull final OutputStream outputStream,
+                               @NonNull NetworkExportCallbacks callbacks) {
+            this.meshManagerApi = meshManagerApi;
+            this.outputStream = outputStream;
+            this.callbacks = callbacks;
+        }
+
+        @Override
+        protected void onPreExecute() {
+            super.onPreExecute();
+        }
+
+        @Override
+        protected Boolean doInBackground(final Void... voids) {
+            final String network = meshManagerApi.exportMeshNetwork();
+            if (network == null)
+                return false;
+            try {
+                outputStream.write(network.getBytes());
+                outputStream.close();
+                return true;
+            } catch (IOException e) {
+                error = e.getMessage();
+                Log.e(TAG, "Exception ex: " + error);
+            }
+            return false;
+        }
+
+        @Override
+        protected void onPostExecute(final Boolean aVoid) {
+            super.onPostExecute(aVoid);
+            if (aVoid) {
+                callbacks.onNetworkExported();
+            } else {
+                callbacks.onNetworkExportFailed(error);
+            }
+        }
+    }
+
+    private static class NetworkExportAsyncTask2 extends AsyncTask<Void, Void, Boolean> {
+
+        private static final String TAG = NetworkExportUtils.NetworkExportAsyncTask.class.getSimpleName();
+        private final MeshManagerApi meshManagerApi;
+        private final String path;
+        private final String fileName;
+        private final NetworkExportCallbacks callbacks;
+        private String error;
+
+        /**
+         * Creates an AsyncTask to import the a mesh network
+         *
+         * @param meshManagerApi Mesh manager api
+         */
+        NetworkExportAsyncTask2(@NonNull final MeshManagerApi meshManagerApi,
+                                @NonNull final String path,
+                                @NonNull final String fileName,
+                                @NonNull NetworkExportCallbacks callbacks) {
+            this.meshManagerApi = meshManagerApi;
+            this.path = path;
+            this.fileName = fileName;
+            this.callbacks = callbacks;
+        }
+
+        @Override
+        protected void onPreExecute() {
+            super.onPreExecute();
+        }
+
+        @Override
+        protected Boolean doInBackground(final Void... voids) {
+            final String network = meshManagerApi.exportMeshNetwork();
+            if (network == null)
+                return false;
+            try {
+                final File directory = new File(path);
+                if (!directory.exists()) {
+                    if (!directory.mkdirs()) {
+                        error = "Unable to create file";
+                        return false;
+                    }
+                }
+                final File file = new File(path, fileName);
+                final BufferedWriter br = new BufferedWriter(new FileWriter(file.getAbsolutePath()));
+                br.write(network);
+                br.flush();
+                br.close();
+                return true;
+            } catch (IOException e) {
+                error = e.getMessage();
+                Log.e(TAG, "Exception ex: " + error);
+            }
+            return false;
+        }
+
+        @Override
+        protected void onPostExecute(final Boolean aVoid) {
+            super.onPostExecute(aVoid);
+            if (aVoid) {
+                callbacks.onNetworkExported();
+            } else {
+                callbacks.onNetworkExportFailed(error);
+            }
+        }
+    }
+}

package/Android-nRF-Mesh-Library/app/src/main/java/no/nordicsemi/android/nrfmesh/utils/ProvisionerDiffCallback.java

@@ -0,0 +1,18 @@
+package no.nordicsemi.android.nrfmesh.utils;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.DiffUtil;
+import no.nordicsemi.android.mesh.Provisioner;
+
+public class ProvisionerDiffCallback extends DiffUtil.ItemCallback<Provisioner> {
+
+    @Override
+    public boolean areItemsTheSame(@NonNull final Provisioner oldItem, @NonNull final Provisioner newItem) {
+        return oldItem.equals(newItem);
+    }
+
+    @Override
+    public boolean areContentsTheSame(@NonNull final Provisioner oldItem, @NonNull final Provisioner newItem) {
+        return oldItem.equals(newItem);
+    }
+}

package/Android-nRF-Mesh-Library/app/src/main/java/no/nordicsemi/android/nrfmesh/utils/ProvisionerStates.java

@@ -0,0 +1,51 @@
+package no.nordicsemi.android.nrfmesh.utils;
+
+public enum ProvisionerStates {
+
+    PROVISIONING_INVITE(0),
+    PROVISIONING_CAPABILITIES(1),
+    PROVISIONING_START(2),
+    PROVISIONING_PUBLIC_KEY_SENT(3),
+    PROVISIONING_PUBLIC_KEY_WAITING(4),
+    PROVISIONING_PUBLIC_KEY_RECEIVED(5),
+    PROVISIONING_AUTHENTICATION_INPUT_OOB_WAITING(6),
+    PROVISIONING_AUTHENTICATION_OUTPUT_OOB_WAITING(7),
+    PROVISIONING_AUTHENTICATION_STATIC_OOB_WAITING(8),
+    PROVISIONING_AUTHENTICATION_INPUT_ENTERED(9),
+    PROVISIONING_INPUT_COMPLETE(10),
+    PROVISIONING_CONFIRMATION_SENT(11),
+    PROVISIONING_CONFIRMATION_RECEIVED(12),
+    PROVISIONING_RANDOM_SENT(13),
+    PROVISIONING_RANDOM_RECEIVED(14),
+    PROVISIONING_DATA_SENT(15),
+    PROVISIONING_COMPLETE(16),
+    PROVISIONING_FAILED(17),
+    COMPOSITION_DATA_GET_SENT(18),
+    COMPOSITION_DATA_STATUS_RECEIVED(19),
+    SENDING_DEFAULT_TTL_GET(20),
+    DEFAULT_TTL_STATUS_RECEIVED(21),
+    SENDING_APP_KEY_ADD(22),
+    APP_KEY_STATUS_RECEIVED(23),
+    SENDING_BLOCK_ACKNOWLEDGEMENT(98),
+    BLOCK_ACKNOWLEDGEMENT_RECEIVED(99),
+    PROVISIONER_UNASSIGNED(100);
+
+    private final int state;
+
+    ProvisionerStates(final int state) {
+        this.state = state;
+    }
+
+    public int getState() {
+        return state;
+    }
+
+    public static ProvisionerStates fromStatusCode(final int statusCode) {
+        for (ProvisionerStates state : ProvisionerStates.values()) {
+            if (state.getState() == statusCode) {
+                return state;
+            }
+        }
+        throw new IllegalStateException("Invalid state");
+    }
+}

package/Android-nRF-Mesh-Library/app/src/main/java/no/nordicsemi/android/nrfmesh/utils/Utils.java

@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) 2018, Nordic Semiconductor
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package no.nordicsemi.android.nrfmesh.utils;
+
+import android.Manifest;
+import android.app.Activity;
+import android.bluetooth.BluetoothAdapter;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.ParcelUuid;
+import android.preference.PreferenceManager;
+import android.provider.Settings;
+
+import java.util.Comparator;
+import java.util.UUID;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+import no.nordicsemi.android.mesh.ApplicationKey;
+import no.nordicsemi.android.mesh.NetworkKey;
+import no.nordicsemi.android.mesh.Scene;
+import no.nordicsemi.android.support.v18.scanner.ScanRecord;
+import no.nordicsemi.android.support.v18.scanner.ScanResult;
+
+@SuppressWarnings("ComparatorCombinators")
+public class Utils {
+
+    public static final String EXTRA_DATA_PROVISIONING_SERVICE = "EXTRA_DATA_PROVISIONING_SERVICE";
+    public static final String HEX_PATTERN = "^[0-9a-fA-F]+$";
+
+    public static final String RESULT_KEY_INDEX = "RESULT_KEY_INDEX";
+    public static final String EDIT_KEY = "EDIT_KEY";
+
+    public static final String EXTRA_DEVICE = "EXTRA_DEVICE";
+    public static final String PROVISIONING_COMPLETED = "PROVISIONING_COMPLETED";
+    public static final String PROVISIONER_UNASSIGNED = "PROVISIONER_UNASSIGNED";
+    public static final String COMPOSITION_DATA_COMPLETED = "COMPOSITION_DATA_COMPLETED";
+    public static final String DEFAULT_GET_COMPLETED = "DEFAULT_GET_COMPLETED";
+    public static final String APP_KEY_ADD_COMPLETED = "APP_KEY_ADD_COMPLETED";
+    // public static final String NETWORK_TRANSMIT_SET_COMPLETED = "NETWORK_TRANSMIT_SET_COMPLETED";
+    public static final String EXTRA_DATA = "EXTRA_DATA";
+    private static final String PREFS_LOCATION_NOT_REQUIRED = "location_not_required";
+    private static final String PREFS_PERMISSION_REQUESTED = "permission_requested";
+    private static final String PREFS_BLUETOOTH_PERMISSION_REQUESTED = "PREFS_BLUETOOTH_PERMISSION_REQUESTED";
+    private static final String PREFS_WRITE_STORAGE_PERMISSION_REQUESTED = "write_storage_permission_requested";
+    public static final String RESULT_KEY = "RESULT_KEY";
+    public static final String RANGE_TYPE = "RANGE_TYPE";
+    public static final String DIALOG_FRAGMENT_KEY_STATUS = "DIALOG_FRAGMENT_KEY_STATUS";
+
+    //Message timeout in case the message fails to lost/received
+    public static final int MESSAGE_TIME_OUT = 10000;
+    //Manage ranges
+    public static final int UNICAST_RANGE = 0;
+    public static final int GROUP_RANGE = 1;
+    public static final int SCENE_RANGE = 2;
+
+    //Manage net keys
+    public static final int MANAGE_NET_KEY = 0;
+    public static final int ADD_NET_KEY = 1;
+
+    //Manage app keys
+    public static final int ADD_APP_KEY = 3;
+    public static final int BIND_APP_KEY = 4;
+    public static final int PUBLICATION_APP_KEY = 5;
+    public static final int SELECT_SCENE = 6;
+
+    // Heartbeat publication key
+    public static final int HEARTBEAT_PUBLICATION_NET_KEY = 6;
+
+    public static final Comparator<NetworkKey> netKeyComparator = (key1, key2) -> Integer.compare(key1.getKeyIndex(), key2.getKeyIndex());
+
+    public static final Comparator<ApplicationKey> appKeyComparator = (key1, key2) -> Integer.compare(key1.getKeyIndex(), key2.getKeyIndex());
+
+    public static final Comparator<Scene> sceneComparator = (scene1, scene2) -> Integer.compare(scene1.getNumber(), scene2.getNumber());
+
+    /**
+     * Checks whether Bluetooth is enabled.
+     *
+     * @return true if Bluetooth is enabled, false otherwise.
+     */
+    public static boolean isBleEnabled() {
+        final BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
+        return adapter != null && adapter.isEnabled();
+    }
+
+    /**
+     * Checks for required permissions.
+     *
+     * @return true if permissions are already granted, false otherwise.
+     */
+    public static boolean isBluetoothScanAndConnectPermissionsGranted(final Context context) {
+        if(!isSorAbove())
+            return true;
+        return ContextCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_SCAN) == PackageManager.PERMISSION_GRANTED &&
+                ContextCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    /**
+     * Returns true if location permission has been requested at least twice and
+     * user denied it, and checked 'Don't ask again'.
+     *
+     * @param activity the activity
+     * @return true if permission has been denied and the popup will not come up any more, false otherwise
+     */
+    @RequiresApi(api = Build.VERSION_CODES.S)
+    public static boolean isBluetoothPermissionDeniedForever(final Activity activity) {
+        final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(activity);
+
+        return !isBluetoothScanAndConnectPermissionsGranted(activity) // Location permission must be denied
+                && preferences.getBoolean(PREFS_BLUETOOTH_PERMISSION_REQUESTED, false) // Permission must have been requested before
+                && !ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.BLUETOOTH_SCAN) // This method should return false
+                && !ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.BLUETOOTH_CONNECT); // This method should return false
+    }
+
+    /**
+     * The first time an app requests a permission there is no 'Don't ask again' checkbox and
+     * {@link ActivityCompat#shouldShowRequestPermissionRationale(Activity, String)} returns false.
+     * This situation is similar to a permission being denied forever, so to distinguish both cases
+     * a flag needs to be saved.
+     *
+     * @param context the context
+     */
+    public static void markBluetoothPermissionsRequested(final Context context) {
+        final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
+        preferences.edit().putBoolean(PREFS_BLUETOOTH_PERMISSION_REQUESTED, true).apply();
+    }
+
+    /**
+     * Checks for required permissions.
+     *
+     * @return true if permissions are already granted, false otherwise.
+     */
+    public static boolean isLocationPermissionsGranted(final Context context) {
+        if(isSorAbove())
+            return true;
+        return ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    /**
+     * Returns true if location permission has been requested at least twice and
+     * user denied it, and checked 'Don't ask again'.
+     *
+     * @param activity the activity
+     * @return true if permission has been denied and the popup will not come up any more, false otherwise
+     */
+    public static boolean isLocationPermissionDeniedForever(final Activity activity) {
+        final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(activity);
+
+        return !isLocationPermissionsGranted(activity) // Location permission must be denied
+                && preferences.getBoolean(PREFS_PERMISSION_REQUESTED, false) // Permission must have been requested before
+                && !ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.ACCESS_FINE_LOCATION); // This method should return false
+    }
+
+    /**
+     * The first time an app requests a permission there is no 'Don't ask again' checkbox and
+     * {@link ActivityCompat#shouldShowRequestPermissionRationale(Activity, String)} returns false.
+     * This situation is similar to a permission being denied forever, so to distinguish both cases
+     * a flag needs to be saved.
+     *
+     * @param context the context
+     */
+    public static void markLocationPermissionRequested(final Context context) {
+        final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
+        preferences.edit().putBoolean(PREFS_PERMISSION_REQUESTED, true).apply();
+    }
+
+    /**
+     * On some devices running Android Marshmallow or newer location services must be enabled in order to scan for Bluetooth LE devices.
+     * This method returns whether the Location has been enabled or not.
+     *
+     * @return true on Android 6.0+ if location mode is different than LOCATION_MODE_OFF. It always returns true on Android versions prior to Marshmallow.
+     */
+    public static boolean isLocationEnabled(final Context context) {
+        if (isWithinMarshmallowAndR()) {
+            int locationMode = Settings.Secure.LOCATION_MODE_OFF;
+            try {
+                locationMode = Settings.Secure.getInt(context.getContentResolver(), Settings.Secure.LOCATION_MODE);
+            } catch (final Settings.SettingNotFoundException e) {
+                // do nothing
+            }
+            return locationMode != Settings.Secure.LOCATION_MODE_OFF;
+        }
+        return true;
+    }
+
+    /**
+     * Location enabled is required on some phones running Android Marshmallow or newer (for example on Nexus and Pixel devices).
+     *
+     * @param context the context
+     * @return false if it is known that location is not required, true otherwise
+     */
+    public static boolean isLocationRequired(final Context context) {
+        final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
+        return preferences.getBoolean(PREFS_LOCATION_NOT_REQUIRED, isWithinMarshmallowAndR());
+    }
+
+    /**
+     * When a Bluetooth LE packet is received while Location is disabled it means that Location
+     * is not required on this device in order to scan for LE devices. This is a case of Samsung phones, for example.
+     * Save this information for the future to keep the Location info hidden.
+     *
+     * @param context the context
+     */
+    public static void markLocationNotRequired(final Context context) {
+        final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
+        preferences.edit().putBoolean(PREFS_LOCATION_NOT_REQUIRED, false).apply();
+    }
+
+    /**
+     * Checks for required permissions.
+     *
+     * @return true if permissions are already granted, false otherwise.
+     */
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+    public static boolean isWriteExternalStoragePermissionsGranted(final Context context) {
+        return ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    /**
+     * The first time an app requests a permission there is no 'Don't ask again' checkbox and
+     * {@link ActivityCompat#shouldShowRequestPermissionRationale(Activity, String)} returns false.
+     * This situation is similar to a permission being denied forever, so to distinguish both cases
+     * a flag needs to be saved.
+     *
+     * @param context the context
+     */
+    public static void markWriteStoragePermissionRequested(final Context context) {
+        final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
+        preferences.edit().putBoolean(PREFS_WRITE_STORAGE_PERMISSION_REQUESTED, true).apply();
+    }
+
+    /**
+     * Returns true if write external permission has been requested at least twice and
+     * user denied it, and checked 'Don't ask again'.
+     *
+     * @param activity the activity
+     * @return true if permission has been denied and the popup will not come up any more, false otherwise
+     */
+    public static boolean isWriteExternalStoragePermissionDeniedForever(final Activity activity) {
+        final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(activity);
+
+        return !isWriteExternalStoragePermissionsGranted(activity) // Location permission must be denied
+                && preferences.getBoolean(PREFS_WRITE_STORAGE_PERMISSION_REQUESTED, false) // Permission must have been requested before
+                && !ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE); // This method should return false
+    }
+
+    public static boolean isSorAbove() {
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.S;
+    }
+
+    public static boolean isWithinMarshmallowAndR() {
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && Build.VERSION.SDK_INT <= Build.VERSION_CODES.R;
+    }
+
+    public static boolean isKitkatOrAbove() {
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
+    }
+
+    @Nullable
+    public static byte[] getServiceData(@NonNull final ScanResult result, @NonNull final UUID serviceUuid) {
+        final ScanRecord scanRecord = result.getScanRecord();
+        if (scanRecord != null) {
+            return scanRecord.getServiceData(new ParcelUuid((serviceUuid)));
+        }
+        return null;
+    }
+}

package/Android-nRF-Mesh-Library/app/src/main/java/no/nordicsemi/android/nrfmesh/viewmodels/AddAppKeyViewModel.java

@@ -0,0 +1,63 @@
+package no.nordicsemi.android.nrfmesh.viewmodels;
+
+import javax.inject.Inject;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+import dagger.hilt.android.lifecycle.HiltViewModel;
+import no.nordicsemi.android.mesh.ApplicationKey;
+import no.nordicsemi.android.nrfmesh.keys.AppKeysActivity;
+
+/**
+ * ViewModel for {@link AppKeysActivity}
+ */
+@HiltViewModel
+public class AddAppKeyViewModel extends BaseViewModel {
+
+    private final ApplicationKey appKey;
+    final MutableLiveData<ApplicationKey> appKeyLiveData = new MutableLiveData<>();
+
+    @Inject
+    AddAppKeyViewModel(@NonNull final NrfMeshRepository nrfMeshRepository) {
+        super(nrfMeshRepository);
+        appKey = getNetworkLiveData().getMeshNetwork().createAppKey();
+        appKeyLiveData.setValue(appKey);
+    }
+
+    public LiveData<ApplicationKey> getAppKeyLiveData() {
+        return appKeyLiveData;
+    }
+
+    /**
+     * Sets the application key
+     *
+     * @param key Key
+     */
+    public void setKey(@NonNull final byte[] key) {
+        appKey.setKey(key);
+        appKeyLiveData.setValue(appKey);
+    }
+
+    /**
+     * Sets the name.
+     *
+     * @param name Application key name.
+     */
+    public void setName(@NonNull final String name) {
+        appKey.setName(name);
+        appKeyLiveData.setValue(appKey);
+    }
+
+    /**
+     * Sets the name.
+     */
+    public void setBoundNetKeyIndex(final int index) {
+        appKey.setBoundNetKeyIndex(index);
+        appKeyLiveData.setValue(appKey);
+    }
+
+    public boolean addAppKey() {
+        return getNetworkLiveData().getMeshNetwork().addAppKey(appKey);
+    }
+}

package/Android-nRF-Mesh-Library/app/src/main/java/no/nordicsemi/android/nrfmesh/viewmodels/AddKeysViewModel.java

@@ -0,0 +1,51 @@
+package no.nordicsemi.android.nrfmesh.viewmodels;
+
+import javax.inject.Inject;
+
+import androidx.annotation.NonNull;
+import dagger.hilt.android.lifecycle.HiltViewModel;
+import no.nordicsemi.android.mesh.transport.ProvisionedMeshNode;
+import no.nordicsemi.android.mesh.utils.MeshParserUtils;
+import no.nordicsemi.android.nrfmesh.keys.AppKeysActivity;
+import no.nordicsemi.android.nrfmesh.keys.NetKeysActivity;
+
+/**
+ * ViewModel for {@link NetKeysActivity}, {@link AppKeysActivity}
+ */
+@HiltViewModel
+public class AddKeysViewModel extends BaseViewModel {
+
+    @Inject
+    AddKeysViewModel(@NonNull final NrfMeshRepository nrfMeshRepository) {
+        super(nrfMeshRepository);
+    }
+
+    /**
+     * Checks if the key has been added to the node
+     *
+     * @param keyIndex index of the key
+     * @return true if added or false otherwise
+     */
+    public boolean isNetKeyAdded(final int keyIndex) {
+        final ProvisionedMeshNode node = getSelectedMeshNode().getValue();
+        if (node != null) {
+            return MeshParserUtils.isNodeKeyExists(node.getAddedNetKeys(), keyIndex);
+        }
+        return false;
+    }
+
+    /**
+     * Checks if the key has been added to the node
+     *
+     * @param keyIndex index of the key
+     * @return true if added or false otherwise
+     */
+    public boolean isAppKeyAdded(final int keyIndex) {
+        final ProvisionedMeshNode node = getSelectedMeshNode().getValue();
+        if (node != null) {
+            return MeshParserUtils.isNodeKeyExists(node.getAddedAppKeys(), keyIndex);
+        }
+        return false;
+    }
+
+}