FloorSelectorView.java

Go to the documentation of this file.

package com.navigine.view.widgets;
 
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.graphics.drawable.GradientDrawable;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.TextView;
 
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.view.ViewCompat;
 
import com.navigine.view.widgets.FloorSelectorViewConfig;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
 
import java.util.ArrayList;
import java.util.List;

public class FloorSelectorView extends FrameLayout {

    public interface OnSublocationSelectedListener {
        void onSublocationSelected(int sublocationId);
    }
 
 
    private List<LevelInfo> floors = new ArrayList<>();
    private int selectedFloorIndex = -1;
 
    private RecyclerView recyclerView;
    private LinearLayoutManager layoutManager;
    private FloorAdapter adapter;
 
    private Button topButton;
    private Button bottomButton;
 
    private OnSublocationSelectedListener onSublocationSelectedListener;
    private FloorSelectorViewConfig config;

    public FloorSelectorView(@NonNull Context context, OnSublocationSelectedListener onSublocationSelected) {
        this(context, onSublocationSelected, null);
    }

    public FloorSelectorView(@NonNull Context context, OnSublocationSelectedListener onSublocationSelected,
                            @Nullable FloorSelectorViewConfig config) {
        super(context);
        this.onSublocationSelectedListener = onSublocationSelected;
        this.config = config;
        init();
    }
 
    private void init() {
        setBackgroundColor(Color.TRANSPARENT);
        setClipChildren(false);
        setClipToPadding(false);
 
        GradientDrawable bg = new GradientDrawable();
        float radius = dpToPx((int) WidgetStyles.BORDER_RADIUS);
        bg.setCornerRadius(radius);
        bg.setColor(Color.WHITE);
        setBackground(bg);
        ViewCompat.setElevation(this, dpToPx((int) WidgetStyles.FLOOR_SELECTOR_SHADOW_ELEVATION));
        setClipToOutline(true);
 
        // RecyclerView
        recyclerView = new RecyclerView(getContext());
        recyclerView.setHasFixedSize(true);
        layoutManager = new LinearLayoutManager(getContext());
        recyclerView.setLayoutManager(layoutManager);
        adapter = new FloorAdapter();
        recyclerView.setAdapter(adapter);
        recyclerView.setOverScrollMode(View.OVER_SCROLL_NEVER);
        recyclerView.setScrollbarFadingEnabled(true);
        recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
            @Override
            public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
                updateButtonVisibility();
            }
        });
 
        recyclerView.addItemDecoration(new DividerDecoration());
 
        addView(recyclerView);
 
        topButton = createArrowButton("▲",true);
        bottomButton = createArrowButton("▼", false);
 
        topButton.setOnClickListener(v -> scrollUp());
        bottomButton.setOnClickListener(v -> scrollDown());
 
        topButton.setVisibility(GONE);
        bottomButton.setVisibility(GONE);
 
        addView(topButton);
        addView(bottomButton);
    }
 
    private Button createArrowButton(String text, boolean isTop) {
        Button button = new Button(getContext());
        button.setText(text);
        button.setTextSize(WidgetStyles.SCROLL_BUTTON_FONT_SIZE);
        button.setTextColor(WidgetStyles.BASE_BLACK);
        button.setTypeface(null, Typeface.BOLD);
        button.setAllCaps(false);
 
        GradientDrawable drawable = new GradientDrawable();
        float radius = dpToPx((int) WidgetStyles.BORDER_RADIUS);
        if (isTop) {
            drawable.setCornerRadii(new float[]{
                    radius, radius,
                    radius, radius,
                    0f, 0f,
                    0f, 0f
            });
        } else {
            drawable.setCornerRadii(new float[]{
                    0f, 0f,
                    0f, 0f,
                    radius, radius,
                    radius, radius
            });
        }
 
        drawable.setColor(WidgetStyles.BUTTON_BACKGROUND_COLOR);
        button.setBackground(drawable);
 
        LayoutParams lp = new LayoutParams(
                ViewGroup.LayoutParams.MATCH_PARENT,
                ViewGroup.LayoutParams.WRAP_CONTENT
        );
        lp.gravity = isTop ? Gravity.TOP : Gravity.BOTTOM;
        button.setLayoutParams(lp);
 
        return button;
    }

    public int getFloorsCount() {
        return floors.size();
    }

    public void applyConfig(@Nullable FloorSelectorViewConfig newConfig) {
        config = newConfig;
        if (adapter != null) {
            adapter.notifyDataSetChanged();
        }
    }

    public void setFloors(List<LevelInfo> newFloors) {
        floors.clear();
        if (newFloors != null) floors.addAll(newFloors);
 
        if (selectedFloorIndex < 0 || selectedFloorIndex >= this.floors.size()) {
            selectedFloorIndex = this.floors.isEmpty() ? -1 : 0;
        }
        updateFrame();
        adapter.notifyDataSetChanged();
        recyclerView.scrollToPosition(selectedFloorIndex >= 0 ? selectedFloorIndex : 0);
        updateButtonVisibility();
    }

    public void setSublocationId(int sublocationId) {
        int newSelectedIndex = -1;
 
        for (int i = 0; i < floors.size(); i++) {
            if (floors.get(i).getSublocationId() == sublocationId) {
                newSelectedIndex = i;
                break;
            }
        }
 
        if (newSelectedIndex == -1) {
            return;
        }
 
        if (selectedFloorIndex == newSelectedIndex) {
            adapter.notifyDataSetChanged();
            updateButtonVisibility();
            return;
        }
 
        selectedFloorIndex = newSelectedIndex;
        adapter.notifyDataSetChanged();
 
        if (floors.size() > WidgetStyles.MAX_VISIBLE_FLOORS) {
            recyclerView.smoothScrollToPosition(selectedFloorIndex);
        } else {
            layoutManager.scrollToPositionWithOffset(selectedFloorIndex, 0);
        }
 
        recyclerView.post(this::updateButtonVisibility);
    }
 
    private void updateFrame() {
        if (floors.isEmpty() || floors.size() == 1) {
            setVisibility(GONE);
        } else {
            setVisibility(VISIBLE);
        }
        requestLayout();
        post(this::updateButtonPositions);
    }
 
    private int dpToPx(float dp) {
        return (int) (dp * getResources().getDisplayMetrics().density + 0.5f);
    }
 
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 
        int rowHeight = dpToPx((int) WidgetStyles.FLOOR_ROW_HEIGHT);
        int count = floors.size();
 
        int desiredWidth = dpToPx((int) WidgetStyles.FLOOR_SELECTOR_WIDTH);
        int desiredHeight;
 
 
        if (count <= 1) {
            desiredHeight = 0;
        } else if (count < WidgetStyles.MAX_VISIBLE_FLOORS) {
            desiredHeight = rowHeight * count;
        } else {
            desiredHeight = rowHeight * WidgetStyles.MAX_VISIBLE_FLOORS;
        }
 
        int width = resolveSize(desiredWidth, widthMeasureSpec);
        int height = resolveSize(desiredHeight, heightMeasureSpec);
 
        setMeasuredDimension(width, height);
 
        int childWidthSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY);
        int childHeightSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
 
        recyclerView.measure(childWidthSpec, childHeightSpec);
 
        int arrowHeightSpec = MeasureSpec.makeMeasureSpec(rowHeight, MeasureSpec.EXACTLY);
        topButton.measure(childWidthSpec, arrowHeightSpec);
        bottomButton.measure(childWidthSpec, arrowHeightSpec);
    }
 
    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        int width = right - left;
        int height = bottom - top;
 
        if (floors.isEmpty() || floors.size() == 1) {
            return;
        }
 
        recyclerView.layout(0, 0, width, height);
 
        int rowHeight = dpToPx((int) WidgetStyles.FLOOR_ROW_HEIGHT);
        topButton.layout(0, 0, width, rowHeight);
        bottomButton.layout(0, height - rowHeight, width, height);
    }
 
    private void updateButtonPositions() {
        if (getHeight() <= 0) return;
        int rowHeight = dpToPx((int) WidgetStyles.FLOOR_ROW_HEIGHT);
        topButton.layout(0, 0, getWidth(), rowHeight);
        bottomButton.layout(0, getHeight() - rowHeight, getWidth(), getHeight());
    }
 
    private void updateButtonVisibility() {
        if (floors.size() <= 1 || floors.size() <= WidgetStyles.MAX_VISIBLE_FLOORS ) {
            topButton.setVisibility(GONE);
            bottomButton.setVisibility(GONE);
            return;
        }
 
        int firstVisible = layoutManager.findFirstCompletelyVisibleItemPosition();
        int lastVisible = layoutManager.findLastCompletelyVisibleItemPosition();
 
        if (firstVisible == RecyclerView.NO_POSITION || lastVisible == RecyclerView.NO_POSITION) {
            topButton.setVisibility(GONE);
            bottomButton.setVisibility(GONE);
            return;
        }
 
        boolean canScrollUp = firstVisible > 0;
        boolean canScrollDown = lastVisible < floors.size() - 1;
 
        topButton.setVisibility(canScrollUp ? VISIBLE : GONE);
        bottomButton.setVisibility(canScrollDown ? VISIBLE : GONE);
    }
 
    private void scrollUp() {
        int firstVisible = layoutManager.findFirstVisibleItemPosition();
        if (firstVisible == RecyclerView.NO_POSITION) return;
        int target = Math.max(0, firstVisible - WidgetStyles.SCROLL_ITEMS_COUNT);
        recyclerView.smoothScrollToPosition(target);
    }
 
    private void scrollDown() {
        int lastVisible = layoutManager.findLastVisibleItemPosition();
        if (lastVisible == RecyclerView.NO_POSITION) return;
        int target = Math.min(floors.size() - 1, lastVisible + WidgetStyles.SCROLL_ITEMS_COUNT);
        recyclerView.smoothScrollToPosition(target);
    }
 
    private class FloorAdapter extends RecyclerView.Adapter<FloorAdapter.ViewHolder> {
        @NonNull
        @Override
        public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
            TextView textView = new TextView(getContext());
            textView.setGravity(Gravity.CENTER);
            textView.setTextSize(WidgetStyles.FLOOR_SELECTOR_FONT_SIZE);
            int horizontalPadding = dpToPx((int) WidgetStyles.FLOOR_SELECTOR_HORIZONTAL_PADDING);
            int verticalPadding = dpToPx((int) WidgetStyles.FLOOR_SELECTOR_VERTICAL_PADDING);
            textView.setPadding(horizontalPadding, verticalPadding, horizontalPadding, verticalPadding);
 
            RecyclerView.LayoutParams lp = new RecyclerView.LayoutParams(
                    ViewGroup.LayoutParams.MATCH_PARENT,
                    dpToPx((int) WidgetStyles.FLOOR_ROW_HEIGHT)
            );
            textView.setLayoutParams(lp);
 
            return new ViewHolder(textView);
        }
 
        @Override
        public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
            LevelInfo info = floors.get(position);
            String displayText = truncateLevelId(info.getLevelId());
            holder.textView.setText(displayText);
 
            boolean isSelected = (position == selectedFloorIndex);
            FloorSelectorViewConfig c = config != null ? config : FloorSelectorViewConfig.defaultConfig();
            int accentColor = c.getAccentColor() != null ? c.getAccentColor() : WidgetStyles.BASE_BLUE;
            int textColor = c.getTextColor() != null ? c.getTextColor() : WidgetStyles.BASE_BLACK;
            holder.textView.setBackgroundColor(isSelected ? accentColor : Color.WHITE);
            holder.textView.setTextColor(isSelected ? Color.WHITE : textColor);
        }
 
        @Override
        public int getItemCount() {
            return floors.size();
        }
 
        class ViewHolder extends RecyclerView.ViewHolder {
            TextView textView;
 
            ViewHolder(@NonNull View itemView) {
                super(itemView);
                textView = (TextView) itemView;
                textView.setOnClickListener(v -> {
                    int pos = getAdapterPosition();
                    if (pos == RecyclerView.NO_POSITION || pos == selectedFloorIndex) return;
 
                    selectedFloorIndex = pos;
                    notifyDataSetChanged();
 
                    LevelInfo info = floors.get(pos);
                    if (onSublocationSelectedListener != null) {
                        onSublocationSelectedListener.onSublocationSelected(info.getSublocationId());
                    }
                });
            }
        }
    }
 
    private class DividerDecoration extends RecyclerView.ItemDecoration {
 
        private final Paint paint = new Paint();
        private final int heightPx;
 
        DividerDecoration() {
            paint.setAntiAlias(true);
            paint.setColor(WidgetStyles.DIVIDER_COLOR);
            heightPx = dpToPx((int) WidgetStyles.DIVIDER_HEIGHT);
        }
 
        @Override
        public void onDrawOver(@NonNull Canvas c,
                               @NonNull RecyclerView parent,
                               @NonNull RecyclerView.State state) {
            int childCount = parent.getChildCount();
            int left = 0;
            int right = parent.getWidth();
 
            for (int i = 0; i < childCount - 1; i++) {
                View child = parent.getChildAt(i);
                float top = child.getBottom();
                float bottom = top + heightPx;
                c.drawRect(left, top, right, bottom, paint);
            }
        }
    }
    private String truncateLevelId(String levelId) {
        if (levelId == null) return "";
        if (levelId.length() <= 5) return levelId;
        return levelId.substring(0, 5) + "...";
    }

    public static class LevelInfo {
        private final String levelId;
        private final int sublocationId;

        public LevelInfo(String levelId, int sublocationId) {
            this.levelId = levelId;
            this.sublocationId = sublocationId;
        }

        public String getLevelId() {
            return levelId;
        }

        public int getSublocationId() {
            return sublocationId;
        }
    }
}