@autorunify/capacitor-nrfmesh 0.0.1

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

@@ -0,0 +1,57 @@
+/*
+ * 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.dialog;
+
+import android.app.Dialog;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AlertDialog;
+import no.nordicsemi.android.nrfmesh.R;
+
+public class DialogFragmentTransactionStatus extends DialogFragmentMessage {
+
+    public static DialogFragmentTransactionStatus newInstance(final String title, final String message) {
+        Bundle args = new Bundle();
+        DialogFragmentTransactionStatus fragment = new DialogFragmentTransactionStatus();
+        args.putString(TITLE, title);
+        args.putString(MESSAGE, message);
+        fragment.setArguments(args);
+        return fragment;
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(final Bundle savedInstanceState) {
+        alertDialogBuilder = new AlertDialog.Builder(requireActivity());
+        alertDialogBuilder.setIcon(R.drawable.ic_error_outline_black);
+        alertDialogBuilder.setPositiveButton(getString(R.string.ok), null);
+
+        return super.onCreateDialog(savedInstanceState);
+    }
+}

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

@@ -0,0 +1,174 @@
+/*
+ * 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.dialog;
+
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.text.Editable;
+import android.text.TextUtils;
+import android.text.TextWatcher;
+import android.text.method.KeyListener;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AlertDialog;
+import androidx.fragment.app.DialogFragment;
+import no.nordicsemi.android.mesh.utils.MeshAddress;
+import no.nordicsemi.android.nrfmesh.R;
+import no.nordicsemi.android.nrfmesh.databinding.DialogFragmentAddressInputBinding;
+import no.nordicsemi.android.nrfmesh.utils.HexKeyListener;
+import no.nordicsemi.android.nrfmesh.utils.Utils;
+
+
+public class DialogFragmentUnicastAddress extends DialogFragment {
+
+    private static final String UNICAST_ADDRESS = "UNICAST_ADDRESS";
+    private static final String ELEMENT_COUNT = "ELEMENT_COUNT";
+
+    private DialogFragmentAddressInputBinding binding;
+
+    private int mUnicastAddress;
+    private int mElementCount;
+
+    public static DialogFragmentUnicastAddress newInstance(final int unicastAddress, final int elementCount) {
+        DialogFragmentUnicastAddress fragmentIvIndex = new DialogFragmentUnicastAddress();
+        final Bundle args = new Bundle();
+        args.putInt(UNICAST_ADDRESS, unicastAddress);
+        args.putInt(ELEMENT_COUNT, elementCount);
+        fragmentIvIndex.setArguments(args);
+        return fragmentIvIndex;
+    }
+
+    @Override
+    public void onCreate(@Nullable final Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        if (getArguments() != null) {
+            mUnicastAddress = getArguments().getInt(UNICAST_ADDRESS);
+            mElementCount = getArguments().getInt(ELEMENT_COUNT);
+        }
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(final Bundle savedInstanceState) {
+        binding = DialogFragmentAddressInputBinding.inflate(getLayoutInflater());
+
+        final KeyListener hexKeyListener = new HexKeyListener();
+        final String unicastAddress = MeshAddress.formatAddress(mUnicastAddress, false);
+        binding.textInputLayout.setHint(getString((R.string.hint_unicast_address)));
+        binding.textInput.setText(unicastAddress);
+        binding.textInput.setSelection(unicastAddress.length());
+        binding.textInput.setKeyListener(hexKeyListener);
+        binding.textInput.addTextChangedListener(new TextWatcher() {
+            @Override
+            public void beforeTextChanged(final CharSequence s, final int start, final int count, final int after) {
+
+            }
+
+            @Override
+            public void onTextChanged(final CharSequence s, final int start, final int before, final int count) {
+                if (TextUtils.isEmpty(s.toString())) {
+                    binding.textInputLayout.setError(getString(R.string.error_empty_unicast_address));
+                } else {
+                    binding.textInputLayout.setError(null);
+                }
+            }
+
+            @Override
+            public void afterTextChanged(final Editable s) {
+
+            }
+        });
+
+        final AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(requireContext())
+                .setIcon(R.drawable.ic_lan_24dp)
+                .setTitle(R.string.title_unicast_address)
+                .setView(binding.getRoot())
+                .setPositiveButton(R.string.ok, null)
+                .setNegativeButton(R.string.cancel, null)
+                .setNeutralButton(R.string.automatic, null);
+
+        binding.summary.setText(R.string.dialog_summary_unicast_address);
+
+        final AlertDialog alertDialog = alertDialogBuilder.show();
+        alertDialog.getButton(DialogInterface.BUTTON_POSITIVE).setOnClickListener(v -> {
+            final String unicast = binding.textInput.getEditableText().toString().trim();
+            try {
+                if (validateInput(unicast)) {
+                    if (((DialogFragmentUnicastAddressListener) requireActivity()).setUnicastAddress(Integer.parseInt(unicast, 16))) {
+                        dismiss();
+                    }
+                }
+            } catch (IllegalArgumentException ex) {
+                binding.textInputLayout.setError(ex.getMessage());
+            }
+        });
+
+        alertDialog.getButton(DialogInterface.BUTTON_NEUTRAL).setOnClickListener(v -> {
+            try {
+                final int unicast = ((DialogFragmentUnicastAddressListener) requireActivity()).getNextUnicastAddress(mElementCount);
+                binding.textInput.setText(MeshAddress.formatAddress(unicast, false));
+            } catch (IllegalArgumentException ex) {
+                binding.textInputLayout.setError(ex.getMessage());
+            }
+        });
+
+        return alertDialog;
+    }
+
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+        binding = null;
+    }
+
+    private boolean validateInput(final String input) {
+
+        try {
+
+            if (input.length() % 4 != 0 || !input.matches(Utils.HEX_PATTERN)) {
+                binding.textInputLayout.setError(getString(R.string.invalid_address_value));
+                return false;
+            }
+
+            final int unicastAddress = Integer.parseInt(input, 16);
+            if (!MeshAddress.isValidUnicastAddress(unicastAddress)) {
+                binding.textInputLayout.setError("Unicast address must range from 0x0001 - 0x7FFFF");
+                return false;
+            }
+        } catch (IllegalArgumentException ex) {
+            binding.textInputLayout.setError(ex.getMessage());
+        }
+
+        return true;
+    }
+    public interface DialogFragmentUnicastAddressListener {
+
+
+        boolean setUnicastAddress(final int unicastAddress);
+
+        int getNextUnicastAddress(final int elementCount);
+
+    }
+}

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

@@ -0,0 +1,11 @@
+package no.nordicsemi.android.nrfmesh.dialog;
+
+import androidx.annotation.NonNull;
+import no.nordicsemi.android.mesh.NetworkKey;
+
+public interface NetKeyListener {
+
+    void onKeyUpdated(@NonNull final NetworkKey key);
+
+    void onKeyNameUpdated(@NonNull final String nodeName);
+}

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

@@ -0,0 +1,227 @@
+/*
+ * 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.export;
+
+import android.Manifest;
+import android.annotation.SuppressLint;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.view.MenuItem;
+
+import com.google.android.material.button.MaterialButton;
+import com.google.android.material.floatingactionbutton.ExtendedFloatingActionButton;
+import com.google.android.material.snackbar.Snackbar;
+
+import java.io.OutputStream;
+
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.contract.ActivityResultContracts;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.appcompat.widget.Toolbar;
+import androidx.core.app.ActivityCompat;
+import androidx.core.widget.NestedScrollView;
+import androidx.lifecycle.ViewModelProvider;
+import androidx.recyclerview.widget.DefaultItemAnimator;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+import dagger.hilt.android.AndroidEntryPoint;
+import no.nordicsemi.android.mesh.NetworkKey;
+import no.nordicsemi.android.mesh.Provisioner;
+import no.nordicsemi.android.nrfmesh.R;
+import no.nordicsemi.android.nrfmesh.databinding.ActivityExportBinding;
+import no.nordicsemi.android.nrfmesh.dialog.DialogFragmentError;
+import no.nordicsemi.android.nrfmesh.dialog.DialogFragmentMeshExportMsg;
+import no.nordicsemi.android.nrfmesh.dialog.DialogFragmentPermissionRationale;
+import no.nordicsemi.android.nrfmesh.export.adapters.SelectableNetworkKeyAdapter;
+import no.nordicsemi.android.nrfmesh.export.adapters.SelectableProvisionerAdapter;
+import no.nordicsemi.android.nrfmesh.provisioners.AddProvisionerActivity;
+import no.nordicsemi.android.nrfmesh.utils.Utils;
+import no.nordicsemi.android.nrfmesh.viewmodels.ExportNetworkViewModel;
+
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+
+@AndroidEntryPoint
+public class ExportNetworkActivity extends AppCompatActivity implements
+        DialogFragmentPermissionRationale.StoragePermissionListener,
+        SelectableProvisionerAdapter.OnItemCheckedChangedListener,
+        SelectableNetworkKeyAdapter.OnItemCheckedChangedListener {
+
+    private static final int REQUEST_STORAGE_PERMISSION = 2023; // random number
+
+    private ActivityExportBinding binding;
+    private ExportNetworkViewModel mViewModel;
+
+    @SuppressLint("NewApi")
+    final ActivityResultLauncher<String> fileExporter = registerForActivityResult(
+            new ActivityResultContracts.CreateDocument("application/json"), uri -> {
+        if (uri != null) {
+            try {
+                final OutputStream stream = getContentResolver().openOutputStream(uri);
+                if (stream != null)
+                    if (mViewModel.exportNetwork(stream)) {
+                        displayExportSuccessSnackBar();
+                    }
+            } catch (Exception ex) {
+                displayExportErrorDialog(ex.getMessage());
+            }
+        }
+    });
+
+    @Override
+    protected void onCreate(@Nullable final Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        binding = ActivityExportBinding.inflate(getLayoutInflater());
+        setContentView(binding.getRoot());
+        mViewModel = new ViewModelProvider(this).get(ExportNetworkViewModel.class);
+
+        final Toolbar toolbar = binding.toolbar;
+        setSupportActionBar(toolbar);
+        if (getSupportActionBar() != null) {
+            getSupportActionBar().setTitle(R.string.export);
+            getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+        }
+
+        final SelectableProvisionerAdapter provisionerAdapter = new SelectableProvisionerAdapter(this, mViewModel.getNetworkLiveData());
+        provisionerAdapter.setOnItemCheckedChangedListener(this);
+        final SelectableNetworkKeyAdapter networkKeyAdapter = new SelectableNetworkKeyAdapter(this, mViewModel.getNetworkLiveData());
+        networkKeyAdapter.setOnItemCheckedChangedListener(this);
+
+        final NestedScrollView nestedScrollView = binding.scrollView;
+        final RecyclerView recyclerViewProvisioners = binding.partialConfigurationContainer.provisioners;
+        final RecyclerView recyclerNetworkKeys = binding.partialConfigurationContainer.networkKeys;
+        final MaterialButton addProvisioner = findViewById(R.id.action_add_provisioner);
+        final ExtendedFloatingActionButton fab = findViewById(R.id.fab_export);
+
+        recyclerViewProvisioners.setLayoutManager(new LinearLayoutManager(this));
+        recyclerViewProvisioners.setItemAnimator(new DefaultItemAnimator());
+        recyclerViewProvisioners.setAdapter(provisionerAdapter);
+
+        recyclerNetworkKeys.setLayoutManager(new LinearLayoutManager(this));
+        recyclerNetworkKeys.setItemAnimator(new DefaultItemAnimator());
+        recyclerNetworkKeys.setAdapter(networkKeyAdapter);
+
+        addProvisioner.setOnClickListener(v -> startActivity(new Intent(this, AddProvisionerActivity.class)));
+
+        nestedScrollView.setOnScrollChangeListener((NestedScrollView.OnScrollChangeListener) (v, scrollX, scrollY, oldScrollX, oldScrollY) -> {
+            if (scrollY == 0) fab.extend();
+            else fab.shrink();
+        });
+
+        fab.setOnClickListener(v -> handleNetworkExport());
+
+        binding.switchExport.setOnCheckedChangeListener((buttonView, isChecked) -> {
+            mViewModel.setExportEverything(isChecked);
+            if (isChecked) {
+                binding.rationaleExportFullConfig.setVisibility(VISIBLE);
+                binding.partialConfigurationContainer.getRoot().setVisibility(GONE);
+            } else {
+                binding.rationaleExportFullConfig.setVisibility(GONE);
+                binding.partialConfigurationContainer.getRoot().setVisibility(VISIBLE);
+            }
+        });
+
+        binding.partialConfigurationContainer.switchExportDeviceKeys.setOnCheckedChangeListener((buttonView, isChecked) -> mViewModel.setExportDeviceKeys(isChecked));
+
+        mViewModel.getExportStatus().observe(this, aVoid -> {
+            if (mViewModel.isExportEverything()) {
+                fab.setEnabled(true);
+            } else {
+                fab.setEnabled(!mViewModel.getProvisioners().isEmpty() && !mViewModel.getNetworkKeys().isEmpty());
+            }
+        });
+
+        mViewModel.getNetworkExportState().observe(this, networkExportState -> {
+            final String title = getString(R.string.title_network_export);
+            final DialogFragmentMeshExportMsg fragment =
+                    DialogFragmentMeshExportMsg.newInstance(R.drawable.ic_info_outline,
+                            title, networkExportState);
+            fragment.show(getSupportFragmentManager(), null);
+        });
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(@NonNull final MenuItem item) {
+        if (item.getItemId() == android.R.id.home) {
+            onBackPressed();
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onProvisionerCheckedChanged(@NonNull final Provisioner provisioner, final boolean isChecked) {
+        if (isChecked)
+            mViewModel.addProvisioner(provisioner);
+        else
+            mViewModel.removeProvisioner(provisioner);
+    }
+
+    @Override
+    public void onNetworkKeyChecked(@NonNull final NetworkKey networkKey, final boolean isChecked) {
+        if (isChecked)
+            mViewModel.addNetworkKey(networkKey);
+        else
+            mViewModel.removeNetworkKey(networkKey);
+    }
+
+    @Override
+    public void onRequestPermissionsResult(final int requestCode, @NonNull final String[] permissions, @NonNull final int[] grantResults) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+        if (requestCode == REQUEST_STORAGE_PERMISSION) {
+            if (PackageManager.PERMISSION_GRANTED != grantResults[0]) {
+                mViewModel.displaySnackBar(this, binding.coordinator, getString(R.string.ext_storage_permission_denied), Snackbar.LENGTH_LONG);
+            }
+        }
+    }
+
+    @Override
+    public void requestPermission() {
+        Utils.markWriteStoragePermissionRequested(this);
+        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, REQUEST_STORAGE_PERMISSION);
+    }
+
+    private void handleNetworkExport() {
+        try {
+            final String networkName = mViewModel.getNetworkLiveData().getNetworkName();
+            fileExporter.launch(networkName);
+        } catch (Exception ex) {
+            displayExportErrorDialog(ex.getMessage());
+        }
+    }
+
+    private void displayExportSuccessSnackBar() {
+        final String message = mViewModel.getNetworkLiveData().getMeshNetwork().getMeshName() + " has been successfully exported.";
+        mViewModel.displaySnackBar(this, binding.coordinator, message, Snackbar.LENGTH_LONG);
+    }
+
+    private void displayExportErrorDialog(final String message) {
+        final String title = getString(R.string.title_network_export);
+        final DialogFragmentError fragment =
+                DialogFragmentError.newInstance(title, message);
+        fragment.show(getSupportFragmentManager(), null);
+    }
+}

package/Android-nRF-Mesh-Library/app/src/main/java/no/nordicsemi/android/nrfmesh/export/adapters/SelectableNetworkKeyAdapter.java

@@ -0,0 +1,117 @@
+/*
+ * 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.export.adapters;
+
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import com.google.android.material.checkbox.MaterialCheckBox;
+import com.google.android.material.elevation.ElevationOverlayProvider;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.recyclerview.widget.AsyncListDiffer;
+import androidx.recyclerview.widget.RecyclerView;
+import no.nordicsemi.android.mesh.NetworkKey;
+import no.nordicsemi.android.mesh.utils.MeshParserUtils;
+import no.nordicsemi.android.nrfmesh.R;
+import no.nordicsemi.android.nrfmesh.databinding.CheckableRowItemBinding;
+import no.nordicsemi.android.nrfmesh.keys.adapter.NetworkKeyDiffCallback;
+import no.nordicsemi.android.nrfmesh.viewmodels.MeshNetworkLiveData;
+
+public class SelectableNetworkKeyAdapter extends RecyclerView.Adapter<SelectableNetworkKeyAdapter.ViewHolder> {
+
+    private final AsyncListDiffer<NetworkKey> differ = new AsyncListDiffer<>(this, new NetworkKeyDiffCallback());
+    private OnItemCheckedChangedListener mOnItemClickListener;
+
+    public SelectableNetworkKeyAdapter(@NonNull final LifecycleOwner owner, @NonNull final MeshNetworkLiveData meshNetworkLiveData) {
+        meshNetworkLiveData.observe(owner, networkData -> {
+            final List<NetworkKey> networkKeys = new ArrayList<>(meshNetworkLiveData.getMeshNetwork().getNetKeys());
+            differ.submitList(networkKeys);
+        });
+    }
+
+    public void setOnItemCheckedChangedListener(final OnItemCheckedChangedListener listener) {
+        mOnItemClickListener = listener;
+    }
+
+    @NonNull
+    @Override
+    public SelectableNetworkKeyAdapter.ViewHolder onCreateViewHolder(@NonNull final ViewGroup parent, final int viewType) {
+        return new ViewHolder(CheckableRowItemBinding.inflate(LayoutInflater.from(parent.getContext()), parent, false));
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull final SelectableNetworkKeyAdapter.ViewHolder holder, final int position) {
+        final NetworkKey key = differ.getCurrentList().get(position);
+        holder.networkKeyName.setText(key.getName());
+        holder.networkKey.setText(MeshParserUtils.bytesToHex(key.getKey(), false).toUpperCase());
+    }
+
+    @Override
+    public long getItemId(final int position) {
+        return position;
+    }
+
+    @Override
+    public int getItemCount() {
+        return differ.getCurrentList().size();
+    }
+
+    @FunctionalInterface
+    public interface OnItemCheckedChangedListener {
+        void onNetworkKeyChecked(@NonNull final NetworkKey networkKey, final boolean isChecked);
+    }
+
+    final class ViewHolder extends RecyclerView.ViewHolder {
+        View container;
+        ImageView icon;
+        TextView networkKeyName;
+        TextView networkKey;
+        MaterialCheckBox materialCheckBox;
+
+        private ViewHolder(@NonNull final CheckableRowItemBinding binding) {
+            super(binding.getRoot());
+            container = binding.container;
+            icon = binding.icon;
+            networkKeyName = binding.title;
+            networkKey = binding.subtitle;
+            materialCheckBox = binding.check;
+            final ElevationOverlayProvider provider = new ElevationOverlayProvider(itemView.getContext());
+            final int color = provider.compositeOverlayIfNeeded(provider.getThemeSurfaceColor(), 3.5f);
+            container.setBackgroundColor(color);
+            icon.setImageDrawable(ContextCompat.getDrawable(itemView.getContext(), R.drawable.ic_vpn_key_24dp));
+            materialCheckBox.setOnCheckedChangeListener((buttonView, isChecked) -> {
+                if (mOnItemClickListener != null)
+                    mOnItemClickListener.onNetworkKeyChecked(differ.getCurrentList().get(getAbsoluteAdapterPosition()), isChecked);
+            });
+        }
+    }
+}