@autorunify/capacitor-nrfmesh 0.0.1

package/Android-nRF-Mesh-Library/app/src/main/java/no/nordicsemi/android/nrfmesh/provisioners/dialogs/DialogFragmentUnicastRange.java

@@ -0,0 +1,191 @@
+/*
+ * 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.provisioners.dialogs;
+
+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.AllocatedUnicastRange;
+import no.nordicsemi.android.mesh.utils.MeshAddress;
+import no.nordicsemi.android.nrfmesh.R;
+import no.nordicsemi.android.nrfmesh.databinding.DialogFragmentRangeBinding;
+import no.nordicsemi.android.nrfmesh.provisioners.RangeListener;
+import no.nordicsemi.android.nrfmesh.utils.HexKeyListener;
+
+public class DialogFragmentUnicastRange extends DialogFragment {
+
+    private static final String RANGE = "RANGE";
+    private DialogFragmentRangeBinding binding;
+    private AllocatedUnicastRange mRange;
+
+    public static DialogFragmentUnicastRange newInstance(@Nullable final AllocatedUnicastRange range) {
+        final DialogFragmentUnicastRange fragment = new DialogFragmentUnicastRange();
+        final Bundle args = new Bundle();
+        args.putParcelable(RANGE, range);
+        fragment.setArguments(args);
+        return fragment;
+    }
+
+    @Override
+    public void onCreate(@Nullable final Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        if (getArguments() != null) {
+            mRange = getArguments().getParcelable(RANGE);
+        }
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(final Bundle savedInstanceState) {
+        binding = DialogFragmentRangeBinding.inflate(getLayoutInflater());
+
+        if (mRange != null) {
+            final String lowAddress = MeshAddress.formatAddress(mRange.getLowAddress(), false);
+            final String highAddress = MeshAddress.formatAddress(mRange.getHighAddress(), false);
+            binding.lowAddressInput.setText(lowAddress);
+            binding.lowAddressInput.setSelection(lowAddress.length());
+            binding.highAddressInput.setText(highAddress);
+            binding.highAddressInput.setSelection(highAddress.length());
+        }
+
+        final KeyListener hexKeyListener = new HexKeyListener();
+        binding.lowAddressInput.setKeyListener(hexKeyListener);
+        binding.lowAddressInput.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.lowAddressLayout.setError(getString(R.string.error_empty_value));
+                } else {
+                    binding.lowAddressLayout.setError(null);
+                }
+            }
+
+            @Override
+            public void afterTextChanged(final Editable s) {
+
+            }
+        });
+
+        binding.highAddressInput.setKeyListener(hexKeyListener);
+        binding.highAddressInput.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.highAddressLayout.setError(getString(R.string.error_empty_value));
+                } else {
+                    binding.highAddressLayout.setError(null);
+                }
+            }
+
+            @Override
+            public void afterTextChanged(final Editable s) {
+
+            }
+        });
+
+        final AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(requireContext())
+                .setView(binding.getRoot())
+                .setIcon(R.drawable.ic_arrow_collapse_black)
+                .setTitle(R.string.title_range)
+                .setPositiveButton(R.string.ok, null)
+                .setNegativeButton(R.string.cancel, null);
+
+        binding.summary.setText(R.string.unicast_range_summary);
+
+        final AlertDialog alertDialog = alertDialogBuilder.show();
+        alertDialog.getButton(DialogInterface.BUTTON_POSITIVE).setOnClickListener(v -> {
+            final String low = binding.lowAddressInput.getEditableText().toString().trim();
+            final String high = binding.highAddressInput.getEditableText().toString().trim();
+            if (validateLow(low) && validateHigh(high)) {
+                try {
+                    AllocatedUnicastRange range = mRange;
+                    if (range == null) {
+                        range = new AllocatedUnicastRange(Integer.parseInt(low, 16), Integer.parseInt(high, 16));
+                        ((RangeListener) requireActivity()).addRange(range);
+                    } else {
+                        AllocatedUnicastRange newRange = (AllocatedUnicastRange) range.clone();
+                        range.setLowAddress(Integer.parseInt(low, 16));
+                        range.setHighAddress(Integer.parseInt(high, 16));
+                        ((RangeListener) requireActivity()).updateRange(range, newRange);
+                    }
+                    dismiss();
+                } catch (IllegalArgumentException ex) {
+                    binding.lowAddressLayout.setError(ex.getMessage());
+                } catch (CloneNotSupportedException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+
+        return alertDialog;
+    }
+
+    private boolean validateLow(final String addressValue) {
+        try {
+
+            final int address = Integer.parseInt(addressValue, 16);
+            if (!MeshAddress.isValidUnicastAddress(address)) {
+                binding.lowAddressLayout.setError("Unicast address value must range from 0x0001 - 0x7FFFF");
+                return false;
+            }
+        } catch (IllegalArgumentException ex) {
+            binding.lowAddressLayout.setError(ex.getMessage());
+            return false;
+        }
+        return true;
+    }
+
+    private boolean validateHigh(final String addressValue) {
+        try {
+
+            final int address = Integer.parseInt(addressValue, 16);
+            if (!MeshAddress.isValidUnicastAddress(address)) {
+                binding.highAddressLayout.setError("Unicast address value must range from 0x0001 - 0x7FFFF");
+                return false;
+            }
+        } catch (IllegalArgumentException ex) {
+            binding.highAddressLayout.setError(ex.getMessage());
+            return false;
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,54 @@
+package no.nordicsemi.android.nrfmesh.scenes;
+
+import androidx.annotation.NonNull;
+import no.nordicsemi.android.mesh.Scene;
+
+public interface SceneCallbacks {
+
+    /**
+     * Creates a scene
+     *
+     * @return {@link Scene}
+     */
+    Scene createScene();
+
+    /**
+     * Creates a scene
+     *
+     * @param name Scene name
+     */
+    Scene createScene(@NonNull final String name);
+
+    /**
+     * Creates a Scene
+     *
+     * @param name   Scene name
+     * @param number Scene number
+     */
+    Scene createScene(@NonNull final String name, final int number);
+
+    /**
+     * Adds a scene
+     *
+     * @param name    Name
+     * @param number Address
+     * @return true if successful or false otherwise
+     */
+    boolean onSceneAdded(@NonNull final String name, final int number);
+
+    /**
+     * Adds a scene
+     *
+     * @param scene {@link Scene}
+     * @return true if successful or false otherwise
+     */
+    boolean onSceneAdded(@NonNull final Scene scene);
+
+    /**
+     * Invoked when a scene is updated
+     *
+     * @param scene Scene
+     * @return true if successful or false otherwise
+     */
+    boolean onSceneUpdated(@NonNull final Scene scene);
+}

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

@@ -0,0 +1,234 @@
+/*
+ * 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.scenes;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.MenuItem;
+import android.view.View;
+
+import com.google.android.material.snackbar.Snackbar;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.lifecycle.ViewModelProvider;
+import androidx.recyclerview.widget.DefaultItemAnimator;
+import androidx.recyclerview.widget.DividerItemDecoration;
+import androidx.recyclerview.widget.ItemTouchHelper;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+import dagger.hilt.android.AndroidEntryPoint;
+import no.nordicsemi.android.mesh.MeshNetwork;
+import no.nordicsemi.android.mesh.Scene;
+import no.nordicsemi.android.nrfmesh.R;
+import no.nordicsemi.android.nrfmesh.databinding.ActivityScenesBinding;
+import no.nordicsemi.android.nrfmesh.scenes.adapter.ManageScenesAdapter;
+import no.nordicsemi.android.nrfmesh.scenes.dialog.DialogFragmentCreateScene;
+import no.nordicsemi.android.nrfmesh.scenes.dialog.DialogFragmentEditScene;
+import no.nordicsemi.android.nrfmesh.viewmodels.ScenesViewModel;
+import no.nordicsemi.android.nrfmesh.widgets.ItemTouchHelperAdapter;
+import no.nordicsemi.android.nrfmesh.widgets.RemovableItemTouchHelperCallback;
+import no.nordicsemi.android.nrfmesh.widgets.RemovableViewHolder;
+
+import static no.nordicsemi.android.nrfmesh.utils.Utils.EXTRA_DATA;
+import static no.nordicsemi.android.nrfmesh.utils.Utils.SELECT_SCENE;
+
+@AndroidEntryPoint
+public class ScenesActivity extends AppCompatActivity implements
+        ManageScenesAdapter.OnItemClickListener,
+        SceneCallbacks,
+        ItemTouchHelperAdapter {
+
+    private ActivityScenesBinding binding;
+    private ScenesViewModel mViewModel;
+
+    private ManageScenesAdapter mAdapter;
+
+    @Override
+    protected void onCreate(@Nullable final Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        binding = ActivityScenesBinding.inflate(getLayoutInflater());
+        setContentView(binding.getRoot());
+        mViewModel = new ViewModelProvider(this).get(ScenesViewModel.class);
+
+        setSupportActionBar(binding.toolbar);
+        if (getSupportActionBar() != null) {
+            getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+        }
+
+        binding.recyclerViewScenes.setLayoutManager(new LinearLayoutManager(this));
+        final DividerItemDecoration dividerItemDecoration =
+                new DividerItemDecoration(binding.recyclerViewScenes.getContext(), DividerItemDecoration.VERTICAL);
+        binding.recyclerViewScenes.addItemDecoration(dividerItemDecoration);
+        binding.recyclerViewScenes.setItemAnimator(new DefaultItemAnimator());
+        binding.recyclerViewScenes.setAdapter(mAdapter = new ManageScenesAdapter(this, mViewModel.getNetworkLiveData()));
+        mAdapter.setOnItemClickListener(this);
+
+        binding.fabAdd.setOnClickListener(v -> {
+                    try {
+                        final Scene scene = createScene();
+                        DialogFragmentCreateScene.newInstance(scene).show(getSupportFragmentManager(), null);
+                    } catch (IllegalArgumentException exception) {
+                        displaySnackBar(exception.getMessage() == null ? getString(R.string.unknwon_error) : exception.getMessage(), null);
+                    }
+                }
+        );
+
+        binding.recyclerViewScenes.addOnScrollListener(new RecyclerView.OnScrollListener() {
+            @Override
+            public void onScrolled(@NonNull final RecyclerView recyclerView, final int dx, final int dy) {
+                super.onScrolled(recyclerView, dx, dy);
+                final LinearLayoutManager m = (LinearLayoutManager) recyclerView.getLayoutManager();
+                if (m != null) {
+                    if (m.findFirstCompletelyVisibleItemPosition() == 0) {
+                        binding.fabAdd.extend();
+                    } else {
+                        binding.fabAdd.shrink();
+                    }
+                }
+            }
+        });
+
+
+        final Bundle bundle = getIntent().getExtras();
+        if (bundle != null && bundle.getInt(EXTRA_DATA) == SELECT_SCENE) {
+            binding.fabAdd.setVisibility(View.GONE);
+            getSupportActionBar().setTitle(R.string.title_select_scene);
+        } else {
+            final ItemTouchHelper.Callback itemTouchHelperCallback = new RemovableItemTouchHelperCallback(this);
+            final ItemTouchHelper itemTouchHelper = new ItemTouchHelper(itemTouchHelperCallback);
+            itemTouchHelper.attachToRecyclerView(binding.recyclerViewScenes);
+            getSupportActionBar().setTitle(R.string.title_manage_scenes);
+        }
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(final MenuItem item) {
+        if (item.getItemId() == android.R.id.home) {
+            onBackPressed();
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onItemDismiss(final RemovableViewHolder viewHolder) {
+        final Scene scene = (Scene) viewHolder.getSwipeableView().getTag();
+        try {
+            final MeshNetwork network = mViewModel.getNetworkLiveData().getMeshNetwork();
+            if (network.removeScene(scene)) {
+                final View.OnClickListener action = v -> {
+                    binding.emptyScenes.getRoot().setVisibility(View.INVISIBLE);
+                    mViewModel.getNetworkLiveData().getMeshNetwork().addScene(scene);
+                };
+                displaySnackBar(getString(R.string.scene_deleted), action);
+                // Show the empty view
+                final boolean empty = mAdapter.getItemCount() == 0;
+                if (empty) {
+                    binding.emptyScenes.getRoot().setVisibility(View.VISIBLE);
+                }
+            }
+        } catch (Exception ex) {
+            mAdapter.update(mViewModel.getNetworkLiveData().getMeshNetwork().getScenes());
+            mViewModel.displaySnackBar(this, binding.container, ex.getMessage() == null ? getString(R.string.unknwon_error) : ex.getMessage(), Snackbar.LENGTH_LONG);
+        }
+    }
+
+    @Override
+    public void onItemDismissFailed(final RemovableViewHolder viewHolder) {
+        //Do nothing
+    }
+
+    private void displaySnackBar(@NonNull final Scene scene) {
+        Snackbar.make(binding.container, getString(R.string.scene_deleted), Snackbar.LENGTH_LONG)
+                .setAction(getString(R.string.undo), view -> {
+                    binding.emptyScenes.getRoot().setVisibility(View.INVISIBLE);
+                    mViewModel.getNetworkLiveData().getMeshNetwork().addScene(scene);
+                })
+                .setActionTextColor(getResources().getColor(R.color.colorSecondary))
+                .show();
+    }
+
+    @SuppressLint("ShowToast")
+    private void displaySnackBar(final String message, final View.OnClickListener action) {
+        Snackbar snack = Snackbar.make(binding.container, message, Snackbar.LENGTH_LONG);
+        if (action != null)
+            snack = snack.setActionTextColor(getResources().getColor(R.color.colorSecondary))
+                    .setAction(R.string.undo, action);
+        snack.show();
+    }
+
+    @Override
+    public void onItemClick(final int position, @NonNull final Scene scene) {
+        final Bundle bundle = getIntent().getExtras();
+        if (bundle != null && bundle.getInt(EXTRA_DATA) == SELECT_SCENE) {
+            final Intent returnIntent = new Intent();
+            returnIntent.putExtra(EXTRA_DATA, scene);
+            setResult(Activity.RESULT_OK, returnIntent);
+            finish();
+        } else
+            DialogFragmentEditScene.newInstance(scene).show(getSupportFragmentManager(), null);
+    }
+
+    @Override
+    public Scene createScene() {
+        final MeshNetwork network = mViewModel.getNetworkLiveData().getMeshNetwork();
+        return network.createScene(network.getSelectedProvisioner());
+    }
+
+    @Override
+    public Scene createScene(@NonNull final String name) {
+        final MeshNetwork network = mViewModel.getNetworkLiveData().getMeshNetwork();
+        return mViewModel.getNetworkLiveData().getMeshNetwork().createScene(network.getSelectedProvisioner(), name);
+    }
+
+    @Override
+    public Scene createScene(@NonNull final String name, final int number) {
+        final MeshNetwork network = mViewModel.getNetworkLiveData().getMeshNetwork();
+        return mViewModel.getNetworkLiveData().getMeshNetwork().createScene(network.getSelectedProvisioner(), number, name);
+    }
+
+    @Override
+    public boolean onSceneAdded(@NonNull final String name, final int number) {
+        final MeshNetwork network = mViewModel.getNetworkLiveData().getMeshNetwork();
+        return mViewModel.getNetworkLiveData().getMeshNetwork().addScene(network.createScene(network.getSelectedProvisioner(), number, name));
+    }
+
+    @Override
+    public boolean onSceneAdded(@NonNull final Scene scene) {
+        return mViewModel.getNetworkLiveData().getMeshNetwork().addScene(scene);
+    }
+
+    @Override
+    public boolean onSceneUpdated(@NonNull final Scene scene) {
+        return mViewModel.getNetworkLiveData().getMeshNetwork().updateScene(scene);
+    }
+
+    @Override
+    public void onBackPressed() {
+        super.onBackPressed();
+    }
+}

package/Android-nRF-Mesh-Library/app/src/main/java/no/nordicsemi/android/nrfmesh/scenes/adapter/ManageScenesAdapter.java

@@ -0,0 +1,122 @@
+/*
+ * 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.scenes.adapter;
+
+import android.view.LayoutInflater;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+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.Scene;
+import no.nordicsemi.android.nrfmesh.R;
+import no.nordicsemi.android.nrfmesh.databinding.RemovableRowItemBinding;
+import no.nordicsemi.android.nrfmesh.utils.Utils;
+import no.nordicsemi.android.nrfmesh.viewmodels.MeshNetworkLiveData;
+import no.nordicsemi.android.nrfmesh.widgets.RemovableViewHolder;
+
+public class ManageScenesAdapter extends RecyclerView.Adapter<ManageScenesAdapter.ViewHolder> {
+
+    private final AsyncListDiffer<Scene> differ = new AsyncListDiffer<>(this, new SceneDiffCallback());
+    private OnItemClickListener mOnItemClickListener;
+
+    public ManageScenesAdapter(@NonNull final LifecycleOwner owner, @NonNull final MeshNetworkLiveData meshNetworkLiveData) {
+        meshNetworkLiveData.observe(owner, networkData -> {
+            final List<Scene> scenes = new ArrayList<>(networkData.getScenes());
+            Collections.sort(scenes, Utils.sceneComparator);
+            differ.submitList(scenes);
+        });
+    }
+
+    public void update(final List<Scene> scenes){
+        final List<Scene> newScenes = new ArrayList<>(scenes);
+        Collections.sort(newScenes, Utils.sceneComparator);
+        differ.submitList(newScenes);
+    }
+
+    public void setOnItemClickListener(final ManageScenesAdapter.OnItemClickListener listener) {
+        mOnItemClickListener = listener;
+    }
+
+    @NonNull
+    @Override
+    public ManageScenesAdapter.ViewHolder onCreateViewHolder(@NonNull final ViewGroup parent, final int viewType) {
+        return new ManageScenesAdapter.ViewHolder(RemovableRowItemBinding.inflate(LayoutInflater.from(parent.getContext()), parent, false));
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull final ManageScenesAdapter.ViewHolder holder, final int position) {
+        if (getItemCount() > 0) {
+            final Scene scene = differ.getCurrentList().get(position);
+            holder.sceneName.setText(scene.getName());
+            final String number = "0x" + String.format(Locale.US, "%04X", scene.getNumber());
+            holder.sceneNumber.setText(number);
+            holder.getSwipeableView().setTag(scene);
+        }
+    }
+
+    @Override
+    public long getItemId(final int position) {
+        return position;
+    }
+
+    @Override
+    public int getItemCount() {
+        return differ.getCurrentList().size();
+    }
+
+    public boolean isEmpty() {
+        return getItemCount() == 0;
+    }
+
+    @FunctionalInterface
+    public interface OnItemClickListener {
+        void onItemClick(final int position, @NonNull final Scene scene);
+    }
+
+    final class ViewHolder extends RemovableViewHolder {
+        TextView sceneName;
+        TextView sceneNumber;
+
+        private ViewHolder(@NonNull final RemovableRowItemBinding binding) {
+            super(binding.getRoot());
+            binding.icon.setImageDrawable(ContextCompat.getDrawable(itemView.getContext(), R.drawable.ic_baseline_palette_24dp));
+            sceneName = binding.title;
+            sceneNumber = binding.subtitle;
+            binding.container.setOnClickListener(v -> {
+                if (mOnItemClickListener != null) {
+                    final Scene scene = differ.getCurrentList().get(getAbsoluteAdapterPosition());
+                    mOnItemClickListener.onItemClick(getAbsoluteAdapterPosition(), scene);
+                }
+            });
+        }
+    }
+}

package/Android-nRF-Mesh-Library/app/src/main/java/no/nordicsemi/android/nrfmesh/scenes/adapter/SceneDiffCallback.java

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

package/Android-nRF-Mesh-Library/app/src/main/java/no/nordicsemi/android/nrfmesh/scenes/adapter/SceneItemDiffCallback.java

@@ -0,0 +1,17 @@
+package no.nordicsemi.android.nrfmesh.scenes.adapter;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.DiffUtil;
+
+public class SceneItemDiffCallback extends DiffUtil.ItemCallback<SceneUiState> {
+
+    @Override
+    public boolean areItemsTheSame(@NonNull final SceneUiState oldItem, @NonNull final SceneUiState newItem) {
+        return oldItem.equals(newItem);
+    }
+
+    @Override
+    public boolean areContentsTheSame(@NonNull final SceneUiState oldItem, @NonNull final SceneUiState newItem) {
+        return oldItem.equals(newItem);
+    }
+}