@autorunify/capacitor-nrfmesh 0.0.1

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

@@ -0,0 +1,60 @@
+package no.nordicsemi.android.nrfmesh.viewmodels;
+
+import javax.inject.Inject;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.MutableLiveData;
+import dagger.hilt.android.lifecycle.HiltViewModel;
+import no.nordicsemi.android.mesh.NetworkKey;
+import no.nordicsemi.android.nrfmesh.keys.AppKeysActivity;
+
+/**
+ * ViewModel for {@link AppKeysActivity}
+ */
+@HiltViewModel
+public class AddNetKeyViewModel extends BaseViewModel {
+
+    private final NetworkKey networkKey;
+    private final MutableLiveData<NetworkKey> networkKeyLiveData = new MutableLiveData<>();
+
+    @Inject
+    AddNetKeyViewModel(@NonNull final NrfMeshRepository nrfMeshRepository) {
+        super(nrfMeshRepository);
+        networkKey = getNetworkLiveData().getMeshNetwork().createNetworkKey();
+        networkKeyLiveData.setValue(networkKey);
+    }
+
+    /**
+     * Returns the LiveData object containing the NetworkKey.
+     */
+    public MutableLiveData<NetworkKey> getNetworkKeyLiveData() {
+        return networkKeyLiveData;
+    }
+
+    /**
+     * Sets the Network Key.
+     *
+     * @param key Key
+     */
+    public void setKey(@NonNull final byte[] key) {
+        networkKey.setKey(key);
+        networkKeyLiveData.setValue(networkKey);
+    }
+
+    /**
+     * Sets the name.
+     *
+     * @param name name.
+     */
+    public void setName(@NonNull final String name) {
+        networkKey.setName(name);
+        networkKeyLiveData.setValue(networkKey);
+    }
+
+    /**
+     * Adds the network key
+     */
+    public boolean addNetKey() {
+        return getNetworkLiveData().getMeshNetwork().addNetKey(networkKey);
+    }
+}

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

@@ -0,0 +1,30 @@
+package no.nordicsemi.android.nrfmesh.viewmodels;
+
+import javax.inject.Inject;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.LiveData;
+import dagger.hilt.android.lifecycle.HiltViewModel;
+import no.nordicsemi.android.mesh.Provisioner;
+import no.nordicsemi.android.nrfmesh.keys.AppKeysActivity;
+
+/**
+ * ViewModel for {@link AppKeysActivity}
+ */
+@HiltViewModel
+public class AddProvisionerViewModel extends BaseViewModel {
+
+    @Inject
+    AddProvisionerViewModel(@NonNull final NrfMeshRepository nrfMeshRepository) {
+        super(nrfMeshRepository);
+        mNrfMeshRepository.clearTransactionStatus();
+    }
+
+    public void setSelectedProvisioner(@NonNull final Provisioner provisioner) {
+        mNrfMeshRepository.setSelectedProvisioner(provisioner);
+    }
+
+    public LiveData<Provisioner> getSelectedProvisioner() {
+        return mNrfMeshRepository.getSelectedProvisioner();
+    }
+}

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

@@ -0,0 +1,19 @@
+package no.nordicsemi.android.nrfmesh.viewmodels;
+
+import javax.inject.Inject;
+
+import androidx.annotation.NonNull;
+import dagger.hilt.android.lifecycle.HiltViewModel;
+import no.nordicsemi.android.nrfmesh.keys.AppKeysActivity;
+
+/**
+ * ViewModel for {@link AppKeysActivity}
+ */
+@HiltViewModel
+public class AddedScenesViewModel extends BaseViewModel {
+
+    @Inject
+    AddedScenesViewModel(@NonNull final NrfMeshRepository nrfMeshRepository) {
+        super(nrfMeshRepository);
+    }
+}

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

@@ -0,0 +1,19 @@
+package no.nordicsemi.android.nrfmesh.viewmodels;
+
+import javax.inject.Inject;
+
+import androidx.annotation.NonNull;
+import dagger.hilt.android.lifecycle.HiltViewModel;
+import no.nordicsemi.android.nrfmesh.keys.AppKeysActivity;
+
+/**
+ * ViewModel for {@link AppKeysActivity}
+ */
+@HiltViewModel
+public class AppKeysViewModel extends BaseViewModel {
+
+    @Inject
+    AppKeysViewModel(@NonNull final NrfMeshRepository nrfMeshRepository) {
+        super(nrfMeshRepository);
+    }
+}

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

@@ -0,0 +1,117 @@
+package no.nordicsemi.android.nrfmesh.viewmodels;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+import no.nordicsemi.android.mesh.transport.MeshMessage;
+import no.nordicsemi.android.nrfmesh.R;
+import no.nordicsemi.android.nrfmesh.dialog.DialogFragmentTransactionStatus;
+
+
+public abstract class BaseActivity extends AppCompatActivity {
+
+    protected BaseViewModel mViewModel;
+    protected Handler mHandler;
+    protected boolean mIsConnected;
+
+    protected abstract void updateClickableViews();
+
+    protected abstract void showProgressBar();
+
+    protected abstract void hideProgressBar();
+
+    protected abstract void enableClickableViews();
+
+    protected abstract void disableClickableViews();
+
+    protected final boolean checkConnectivity(final CoordinatorLayout container) {
+        if (!mIsConnected) {
+            mViewModel.displayDisconnectedSnackBar(this, container);
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Update the mesh message
+     *
+     * @param meshMessage {@link MeshMessage} mesh message status
+     */
+    protected abstract void updateMeshMessage(final MeshMessage meshMessage);
+
+    protected final Runnable mRunnableOperationTimeout = () -> {
+        hideProgressBar();
+        mViewModel.getMessageQueue().clear();
+        if (mViewModel.isActivityVisible()) {
+            DialogFragmentTransactionStatus fragmentMessage = DialogFragmentTransactionStatus.
+                    newInstance(getString(R.string.title_transaction_failed), getString(R.string.operation_timed_out));
+            fragmentMessage.show(getSupportFragmentManager(), null);
+        }
+    };
+
+    @Override
+    public boolean onCreateOptionsMenu(final Menu menu) {
+        if (mIsConnected) {
+            getMenuInflater().inflate(R.menu.disconnect, menu);
+        } else {
+            getMenuInflater().inflate(R.menu.connect, menu);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(@NonNull final MenuItem item) {
+        final int id = item.getItemId();
+        if (id == android.R.id.home) {
+            onBackPressed();
+            return true;
+        } else if (id == R.id.action_connect) {
+            mViewModel.navigateToScannerActivity(this, false);
+            return true;
+        } else if (id == R.id.action_disconnect) {
+            mViewModel.disconnect();
+            return true;
+        }
+        return false;
+    }
+
+    protected final void initialize() {
+        mHandler = new Handler(Looper.getMainLooper());
+        mViewModel.isConnectedToProxy().observe(this, isConnected -> {
+            if (isConnected != null) {
+                mIsConnected = isConnected;
+                hideProgressBar();
+                updateClickableViews();
+            }
+            invalidateOptionsMenu();
+        });
+
+        mViewModel.getMeshMessage().observe(this, this::updateMeshMessage);
+
+        final Boolean isConnectedToNetwork = mViewModel.isConnectedToProxy().getValue();
+        if (isConnectedToNetwork != null) {
+            mIsConnected = isConnectedToNetwork;
+        }
+
+        mViewModel.getTransactionStatus().observe(this, transactionStatus -> {
+            if (transactionStatus != null) {
+                hideProgressBar();
+                final String message;
+                if (transactionStatus.isIncompleteTimerExpired()) {
+                    message = getString(R.string.segments_not_received_timed_out);
+                } else {
+                    message = getString(R.string.operation_timed_out);
+                }
+                DialogFragmentTransactionStatus fragmentMessage = DialogFragmentTransactionStatus.newInstance(getString(R.string.title_transaction_failed), message);
+                fragmentMessage.show(getSupportFragmentManager(), null);
+            }
+        });
+
+        invalidateOptionsMenu();
+    }
+}

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

@@ -0,0 +1,358 @@
+package no.nordicsemi.android.nrfmesh.viewmodels;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+
+import com.google.android.material.snackbar.Snackbar;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+import androidx.annotation.NonNull;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.ViewModel;
+import no.nordicsemi.android.mesh.MeshManagerApi;
+import no.nordicsemi.android.mesh.models.VendorModel;
+import no.nordicsemi.android.mesh.transport.Element;
+import no.nordicsemi.android.mesh.transport.MeshMessage;
+import no.nordicsemi.android.mesh.transport.MeshModel;
+import no.nordicsemi.android.mesh.transport.ProvisionedMeshNode;
+import no.nordicsemi.android.nrfmesh.R;
+import no.nordicsemi.android.nrfmesh.adapter.ExtendedBluetoothDevice;
+import no.nordicsemi.android.nrfmesh.ble.BleMeshManager;
+import no.nordicsemi.android.nrfmesh.ble.ScannerActivity;
+import no.nordicsemi.android.nrfmesh.node.ConfigurationClientActivity;
+import no.nordicsemi.android.nrfmesh.node.ConfigurationServerActivity;
+import no.nordicsemi.android.nrfmesh.node.GenericBatteryServerActivity;
+import no.nordicsemi.android.nrfmesh.node.GenericLevelServerActivity;
+import no.nordicsemi.android.nrfmesh.node.GenericModelConfigurationActivity;
+import no.nordicsemi.android.nrfmesh.node.GenericOnOffServerActivity;
+import no.nordicsemi.android.nrfmesh.node.GenericPowerOnOffServerActivity;
+import no.nordicsemi.android.nrfmesh.node.GenericPowerOnOffSetupServerActivity;
+import no.nordicsemi.android.nrfmesh.node.PowerLevelServerActivity;
+import no.nordicsemi.android.nrfmesh.node.PowerLevelSetupServerActivity;
+import no.nordicsemi.android.nrfmesh.node.GenericDefaultTransitionTimeServerActivity;
+import no.nordicsemi.android.nrfmesh.node.PropertyServerActivity;
+import no.nordicsemi.android.nrfmesh.node.SceneServerModelActivity;
+import no.nordicsemi.android.nrfmesh.node.SceneSetupServerModelActivity;
+import no.nordicsemi.android.nrfmesh.node.SensorServerActivity;
+import no.nordicsemi.android.nrfmesh.node.TimeServerActivity;
+import no.nordicsemi.android.nrfmesh.node.TimeSetupServerActivity;
+import no.nordicsemi.android.nrfmesh.node.VendorModelActivity;
+import no.nordicsemi.android.nrfmesh.utils.Utils;
+
+import static no.nordicsemi.android.mesh.models.SigModelParser.CONFIGURATION_CLIENT;
+import static no.nordicsemi.android.mesh.models.SigModelParser.CONFIGURATION_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.GENERIC_BATTERY_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.GENERIC_LEVEL_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.GENERIC_MANUFACTURER_PROPERTY_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.GENERIC_ON_OFF_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.GENERIC_POWER_ON_OFF_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.GENERIC_POWER_ON_OFF_SETUP_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.GENERIC_POWER_LEVEL_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.GENERIC_POWER_LEVEL_SETUP_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.GENERIC_DEFAULT_TRANSITION_TIME_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.SCENE_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.SCENE_SETUP_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.SENSOR_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.TIME_SERVER;
+import static no.nordicsemi.android.mesh.models.SigModelParser.TIME_SETUP_SERVER;
+
+/**
+ * abstract base class for ViewModels
+ */
+public abstract class BaseViewModel extends ViewModel {
+
+    protected Queue<MeshMessage> messageQueue = new LinkedList<>();
+    final NrfMeshRepository mNrfMeshRepository;
+    boolean isActivityVisible = false;
+
+
+    /**
+     * Constructs {@link BaseViewModel}
+     *
+     * @param nRfMeshRepository Mesh Repository {@link NrfMeshRepository}
+     */
+    BaseViewModel(@NonNull final NrfMeshRepository nRfMeshRepository) {
+        mNrfMeshRepository = nRfMeshRepository;
+    }
+
+    @Override
+    protected void onCleared() {
+        super.onCleared();
+    }
+
+    /**
+     * Returns the Mesh repository
+     */
+    public final NrfMeshRepository getNrfMeshRepository() {
+        return mNrfMeshRepository;
+    }
+
+    /**
+     * Returns the {@link BleMeshManager}
+     */
+    public final BleMeshManager getBleMeshManager() {
+        return mNrfMeshRepository.getBleMeshManager();
+    }
+
+    public Queue<MeshMessage> getMessageQueue() {
+        return messageQueue;
+    }
+
+    public void removeMessage() {
+        if (!messageQueue.isEmpty())
+            messageQueue.remove();
+    }
+
+    /**
+     * Navigate to scanner activity
+     *
+     * @param context                 Activity context
+     * @param withProvisioningService Scan with provisioning service
+     */
+    public void navigateToScannerActivity(@NonNull final Context context, final boolean withProvisioningService) {
+        final Intent intent = new Intent(context, ScannerActivity.class);
+        intent.putExtra(Utils.EXTRA_DATA_PROVISIONING_SERVICE, withProvisioningService);
+        context.startActivity(intent);
+    }
+
+    /**
+     * Start activity based on the type of the model
+     *
+     * <p> This way we can seperate the ui logic for different activities</p>
+     *
+     * @param context Activity context
+     * @param model   {@link MeshModel}
+     */
+    public void navigateToModelActivity(@NonNull final Activity context, @NonNull final MeshModel model) {
+        final Intent intent;
+        if (model.getModelId() == CONFIGURATION_SERVER) {
+            intent = new Intent(context, ConfigurationServerActivity.class);
+        } else if (model.getModelId() == CONFIGURATION_CLIENT) {
+            intent = new Intent(context, ConfigurationClientActivity.class);
+        } else if (model.getModelId() == GENERIC_ON_OFF_SERVER) {
+            intent = new Intent(context, GenericOnOffServerActivity.class);
+        } else if (model.getModelId() == GENERIC_POWER_ON_OFF_SERVER) {
+            intent = new Intent(context, GenericPowerOnOffServerActivity.class);
+        } else if (model.getModelId() == GENERIC_POWER_ON_OFF_SETUP_SERVER) {
+            intent = new Intent(context, GenericPowerOnOffSetupServerActivity.class);
+        } else if (model.getModelId() == GENERIC_BATTERY_SERVER) {
+            intent = new Intent(context, GenericBatteryServerActivity.class);
+        } else if (model.getModelId() == GENERIC_DEFAULT_TRANSITION_TIME_SERVER) {
+            intent = new Intent(context, GenericDefaultTransitionTimeServerActivity.class);
+        } else if (model.getModelId() == GENERIC_LEVEL_SERVER) {
+            intent = new Intent(context, GenericLevelServerActivity.class);
+        } else if (model.getModelId() == GENERIC_POWER_LEVEL_SERVER) {
+            intent = new Intent(context, PowerLevelServerActivity.class);
+        } else if (model.getModelId() == GENERIC_POWER_LEVEL_SETUP_SERVER) {
+            intent = new Intent(context, PowerLevelSetupServerActivity.class);
+        } else if (model.getModelId() == SCENE_SERVER) {
+            intent = new Intent(context, SceneServerModelActivity.class);
+        } else if (model.getModelId() == SCENE_SETUP_SERVER) {
+            intent = new Intent(context, SceneSetupServerModelActivity.class);
+        } else if (model.getModelId() == SENSOR_SERVER) {
+            intent = new Intent(context, SensorServerActivity.class);
+        } else if (model.getModelId() == GENERIC_MANUFACTURER_PROPERTY_SERVER) {
+            intent = new Intent(context, PropertyServerActivity.class);
+        } else if (model.getModelId() == TIME_SERVER) {
+            intent = new Intent(context, TimeServerActivity.class);
+        } else if (model.getModelId() == TIME_SETUP_SERVER) {
+            intent = new Intent(context, TimeSetupServerActivity.class);
+        } else if (model instanceof VendorModel) {
+            intent = new Intent(context, VendorModelActivity.class);
+        } else {
+            intent = new Intent(context, GenericModelConfigurationActivity.class);
+        }
+        context.startActivity(intent);
+    }
+
+    /**
+     * Connect to peripheral
+     *
+     * @param context          Context
+     * @param device           {@link ExtendedBluetoothDevice} device
+     * @param connectToNetwork True if connecting to an unprovisioned node or proxy node
+     */
+    public final void connect(@NonNull final Context context, @NonNull final ExtendedBluetoothDevice device, final boolean connectToNetwork) {
+        mNrfMeshRepository.connect(context, device, connectToNetwork);
+    }
+
+    /**
+     * Disconnect from peripheral
+     */
+    public final void disconnect() {
+        mNrfMeshRepository.disconnect();
+    }
+
+    /**
+     * Returns the address of the connected proxy address
+     */
+    public final LiveData<Integer> getConnectedProxyAddress() {
+        return mNrfMeshRepository.getConnectedProxyAddress();
+    }
+
+    /**
+     * Returns true currently connected to a peripheral device.
+     */
+    public final LiveData<Boolean> isConnected() {
+        return mNrfMeshRepository.isConnected();
+    }
+
+    /**
+     * Returns true if the device is ready
+     */
+    public final LiveData<Void> isDeviceReady() {
+        return mNrfMeshRepository.isDeviceReady();
+    }
+
+    /**
+     * Returns the connection state
+     */
+    public final LiveData<String> getConnectionState() {
+        return mNrfMeshRepository.getConnectionState();
+    }
+
+    /**
+     * Returns true if currently connected to the proxy node in the mesh network.
+     */
+    public final LiveData<Boolean> isConnectedToProxy() {
+        return mNrfMeshRepository.isConnectedToProxy();
+    }
+
+    /**
+     * Returns the mesh manager api
+     */
+    public final MeshManagerApi getMeshManagerApi() {
+        return mNrfMeshRepository.getMeshManagerApi();
+    }
+
+    /**
+     * Returns live data object containing provisioning settings.
+     */
+    public final MeshNetworkLiveData getNetworkLiveData() {
+        return mNrfMeshRepository.getMeshNetworkLiveData();
+    }
+
+    /**
+     * Returns the provisioned nodes as a live data object.
+     */
+    public LiveData<List<ProvisionedMeshNode>> getNodes() {
+        return mNrfMeshRepository.getNodes();
+    }
+
+    /**
+     * Get selected {@link ProvisionedMeshNode} mesh node
+     */
+    public final LiveData<ProvisionedMeshNode> getSelectedMeshNode() {
+        return mNrfMeshRepository.getSelectedMeshNode();
+    }
+
+    /**
+     * Set selected mesh node
+     *
+     * @param node {@link ProvisionedMeshNode}
+     */
+    public final void setSelectedMeshNode(@NonNull final ProvisionedMeshNode node) {
+        mNrfMeshRepository.setSelectedMeshNode(node);
+    }
+
+    /**
+     * Get selected element
+     */
+    public final LiveData<Element> getSelectedElement() {
+        return mNrfMeshRepository.getSelectedElement();
+    }
+
+    /**
+     * Set the element to be configured
+     *
+     * @param element {@link Element}
+     */
+    public final void setSelectedElement(@NonNull final Element element) {
+        mNrfMeshRepository.setSelectedElement(element);
+    }
+
+    /**
+     * Get selected model
+     */
+    public final LiveData<MeshModel> getSelectedModel() {
+        return mNrfMeshRepository.getSelectedModel();
+    }
+
+    /**
+     * Set the mesh model to be configured
+     *
+     * @param model {@link MeshModel}
+     */
+    public final void setSelectedModel(@NonNull final MeshModel model) {
+        mNrfMeshRepository.setSelectedModel(model);
+    }
+
+    /**
+     * Reset mesh network
+     */
+    public final void resetMeshNetwork() {
+        mNrfMeshRepository.resetMeshNetwork();
+    }
+
+    /**
+     * Returns the LiveData containing {@link MeshMessage}
+     */
+    public final LiveData<MeshMessage> getMeshMessage() {
+        return mNrfMeshRepository.getMeshMessageLiveData();
+    }
+
+    /**
+     * Returns an observable live data object containing the transaction status.
+     *
+     * @return {@link TransactionStatus}
+     */
+    public final LiveData<TransactionStatus> getTransactionStatus() {
+        return mNrfMeshRepository.getTransactionStatus();
+    }
+
+    public boolean isModelExists(final int modelId) {
+        final ProvisionedMeshNode node = getSelectedMeshNode().getValue();
+        return node != null && node.isExist(modelId);
+    }
+
+    /**
+     * Display disconnected snack bar
+     *
+     * @param context   Activity context
+     * @param container container
+     */
+    public void displayDisconnectedSnackBar(@NonNull final Activity context, @NonNull final CoordinatorLayout container) {
+        Snackbar.make(container, context.getString(R.string.disconnected_network_rationale), Snackbar.LENGTH_LONG)
+                .setActionTextColor(context.getResources().getColor(R.color.colorSecondary))
+                .setAction(context.getString(R.string.action_connect), v ->
+                        navigateToScannerActivity(context, false))
+                .show();
+    }
+
+    /**
+     * Display snack bar
+     *
+     * @param context   Activity context
+     * @param container Coordinator layout
+     * @param message   Message
+     * @param duration  Snack bar duration
+     */
+    public void displaySnackBar(@NonNull final Context context, @NonNull final CoordinatorLayout container, @NonNull final String message, final int duration) {
+        Snackbar.make(container, message, duration)
+                .setActionTextColor(context.getResources().getColor(R.color.colorSecondary))
+                .show();
+    }
+
+    public boolean isActivityVisible() {
+        return isActivityVisible;
+    }
+
+    public void setActivityVisible(final boolean visible) {
+        isActivityVisible = visible;
+    }
+}

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

@@ -0,0 +1,85 @@
+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 EditAppKeyViewModel extends BaseViewModel {
+
+    private ApplicationKey appKey;
+    final MutableLiveData<ApplicationKey> appKeyLiveData = new MutableLiveData<>();
+
+    @Inject
+    EditAppKeyViewModel(@NonNull final NrfMeshRepository nrfMeshRepository) {
+        super(nrfMeshRepository);
+    }
+
+    /**
+     * Returns the app key live data
+     */
+    public LiveData<ApplicationKey> getAppKeyLiveData() {
+        return appKeyLiveData;
+    }
+
+    /**
+     * Selects the key based on the application key index.
+     *
+     * @param index key index
+     */
+    public void selectAppKey(final int index) {
+        appKey = getNetworkLiveData().getMeshNetwork().getAppKey(index);
+        appKeyLiveData.setValue(appKey);
+    }
+
+    /**
+     * Sets the application key
+     *
+     * @param key Key
+     * @return true if successful or false otherwise
+     */
+    public boolean setKey(@NonNull final String key) {
+        if (getNetworkLiveData().getMeshNetwork().updateAppKey(appKey, key)) {
+            selectAppKey(appKey.getKeyIndex());
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Sets the name.
+     *
+     * @param name Application key name.
+     */
+    public boolean setName(@NonNull final String name) {
+        appKey.setName(name);
+        if (getNetworkLiveData().getMeshNetwork().updateAppKey(appKey)) {
+            selectAppKey(appKey.getKeyIndex());
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Sets the bound net key index.
+     */
+    public void setBoundNetKeyIndex(final int index) {
+        try {
+            final ApplicationKey appKey = this.appKey.clone();
+            appKey.setBoundNetKeyIndex(index);
+            if (getNetworkLiveData().getMeshNetwork().updateAppKey(appKey)) {
+                selectAppKey(appKey.getKeyIndex());
+            }
+        } catch (CloneNotSupportedException e) {
+            e.printStackTrace();
+        }
+    }
+}