implementation 'androidx.appcompat:appcompat:1.3.1'

    implementation "androidx.viewpager2:viewpager2:1.0.0"

import androidx.annotation.NonNull;

import androidx.fragment.app.FragmentManager;

import androidx.viewpager2.widget.ViewPager2;

import com.google.android.material.tabs.TabLayout;

import com.google.android.material.tabs.TabLayoutMediator;

import java.util.List;

import eu.lepiller.nani.result.KanjiResult;

import static java.lang.Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS;

    private LinearLayout result_layout;

    ViewPager2 viewPager2;

    ResultPagerAdapter pagerAdapter;

    static final String TAG = "MAIN";

        TabLayout tabLayout = findViewById(R.id.tab_layout);

        viewPager2 = findViewById(R.id.pager);

        Button radical_button = findViewById(R.id.radical_button);

        pagerAdapter = new ResultPagerAdapter(this.getApplicationContext());

        pagerAdapter.setReadingStyle(readingStyle);

        pagerAdapter.notifyDataSetChanged();

        viewPager2.setAdapter(pagerAdapter);

        tabLayout.addTab(tabLayout.newTab().setText(R.string.tab_results));

        tabLayout.addTab(tabLayout.newTab().setText(R.string.tab_kanji));

        new TabLayoutMediator(tabLayout, viewPager2,

                new TabLayoutMediator.TabConfigurationStrategy() {

                    @Override

                    public void onConfigureTab(@NonNull TabLayout.Tab tab, int position) {

                        tab.setText(position == 0? R.string.tab_results: R.string.tab_kanji);

                    }

                }

        ).attach();

                pagerAdapter.setKanjiResults(new ArrayList<KanjiResult>());

                pagerAdapter.setResults(new ArrayList<Result>());

                pagerAdapter.notifyDataSetChanged();

            pagerAdapter.setReadingStyle(readingStyle);

            pagerAdapter.notifyDataSetChanged();

            List<KanjiResult> kanjiResults = new ArrayList<>();

            for(String c: text.split("")) {

                if(Character.UnicodeBlock.of(c.codePointAt(0)) == CJK_UNIFIED_IDEOGRAPHS) {

                    KanjiResult r;

                    try {

                        r = DictionaryFactory.searchKanji(c);

                    } catch(DictionaryException e) {

                        return new SearchResult(e);

                    }

                    Log.d(TAG, "kanji " + c + ", result: " + r);

                    if(r != null)

                        kanjiResults.add(r);

                }

            }

                return new SearchResult(searchResult, kanjiResults, text, true);

                return new SearchResult(searchResult, kanjiResults, text, false);

        List<Result> searchResult = r.getResults();

        List<KanjiResult> kanjiResults = r.getKanjiResults();

        Log.d(TAG, "results. Kanjis: " + r.getKanjiResults().size());

        if(searchResult != null || kanjiResults != null) {

            if((searchResult == null || searchResult.size() == 0) && kanjiResults.size() == 0) {

                feedback_text.setText(R.string.feedback_no_result);

        pagerAdapter.setKanjiResults(kanjiResults);

        pagerAdapter.setResults(searchResult);

        pagerAdapter.notifyDataSetChanged();

package eu.lepiller.nani;

import android.content.Context;

import android.content.Intent;

import android.os.Build;

import android.text.Html;

import android.util.Log;

import android.view.Gravity;

import android.view.LayoutInflater;

import android.view.View;

import android.view.ViewGroup;

import android.widget.LinearLayout;

import android.widget.TextView;

import androidx.annotation.NonNull;

import androidx.recyclerview.widget.RecyclerView;

import org.w3c.dom.Text;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import eu.lepiller.nani.result.KanjiResult;

import eu.lepiller.nani.result.Result;

import se.fekete.furiganatextview.furiganaview.FuriganaTextView;

public class ResultPagerAdapter extends RecyclerView.Adapter<ResultPagerAdapter.ViewHolder> {

    static List<Result> results = new ArrayList<>();

    static List<KanjiResult> kanjiResults = new ArrayList<>();

    private static String readingStyle = "furigana";

    private Context context;

    static final String TAG = "RESULTS_PAGER";

    public static class ViewHolder extends RecyclerView.ViewHolder {

        private LinearLayout result_view;

        private Context context;

        ViewHolder(View view, Context context) {

            super(view);

            this.context = context;

            result_view = view.findViewById(R.id.results_view);

            Log.d(TAG, "createView");

        }

        final String getContent(List<String> content) {

            StringBuilder sb = new StringBuilder();

            boolean separator1 = false;

            for (String s : content) {

                if (separator1)

                    sb.append(context.getResources().getString(R.string.sense_separator));

                else

                    separator1 = true;

                sb.append(s);

            }

            return sb.toString();

        }

        void showKanjiResults() {

            result_view.removeAllViews();

            if(kanjiResults == null)

                return;

            Log.d(TAG, "(show) kanjis: " + kanjiResults.size());

            for(KanjiResult result: kanjiResults) {

                View child_result = LayoutInflater.from(context).inflate(R.layout.layout_kanji, result_view, false);

                TextView kanjiView = child_result.findViewById(R.id.kanji_view);

                TextView strokesView = child_result.findViewById(R.id.kanji_strokes);

                LinearLayout senses_view = child_result.findViewById(R.id.sense_view);

                TextView onView = child_result.findViewById(R.id.on_reading);

                TextView kunView = child_result.findViewById(R.id.kun_reading);

                TextView nanoriView = child_result.findViewById(R.id.nanori_reading);

                kanjiView.setText(result.getKanji());

                strokesView.setText(String.format(context.getResources().getQuantityString(R.plurals.kanji_stroke, result.getStroke()),

                        result.getStroke()));

                senses_view.removeAllViews();

                Map<String, List<String>> meanings = new HashMap<>();

                for(KanjiResult.Sense sense: result.getSenses()) {

                    List<String> content = meanings.get(sense.getLang());

                    if(content == null)

                        content = new ArrayList<>();

                    content.add(sense.getContent());

                    meanings.put(sense.getLang(), content);

                }

                int sense_pos = 1;

                for(String lang: meanings.keySet()) {

                    View child = LayoutInflater.from(context).inflate(R.layout.layout_sense, senses_view, false);

                    TextView id_view = child.findViewById(R.id.id_view);

                    TextView lang_view = child.findViewById(R.id.lang_view);

                    TextView sense_view = child.findViewById(R.id.definition_view);

                    id_view.setText(String.format(context.getResources().getString(R.string.sense_number), sense_pos));

                    lang_view.setText(lang);

                    StringBuilder sb = new StringBuilder();

                    boolean separator1 = false;

                    for (String s : meanings.get(lang)) {

                        if (separator1)

                            sb.append(context.getResources().getString(R.string.sense_separator));

                        else

                            separator1 = true;

                        sb.append(s);

                    }

                    sense_view.setText(Html.fromHtml(sb.toString()));

                    senses_view.addView(child);

                    sense_pos++;

                }

                kunView.setText(String.format(context.getResources().getString(R.string.kun_reading),

                        getContent(result.getKun())));

                onView.setText(String.format(context.getResources().getString(R.string.on_reading),

                        getContent(result.getOn())));

                nanoriView.setText(String.format(context.getResources().getString(R.string.nanori_reading),

                        getContent(result.getNanori())));

                result_view.addView(child_result);

            }

        }

        void showResults() {

            result_view.removeAllViews();

            if(results == null)

                return;

            int num = 0;

            for(Result result: results) {

                num++;

                if (num > 10)

                    break;

                View child_result = LayoutInflater.from(context).inflate(R.layout.layout_result, result_view, false);

                FuriganaTextView kanji_view = child_result.findViewById(R.id.kanji_view);

                TextView reading_view = child_result.findViewById(R.id.reading_view);

                LinearLayout senses_view = child_result.findViewById(R.id.sense_view);

                TextView additional_info = child_result.findViewById(R.id.additional_info_view);

                TextView pitch_view = child_result.findViewById(R.id.pitch_view);

                // Populate the data into the template view using the data object

                if(readingStyle.compareTo("furigana") == 0) {

                    kanji_view.setFuriganaText(result.getKanjiFurigana());

                } else {

                    kanji_view.setFuriganaText(result.getKanji());

                    reading_view.setVisibility(View.VISIBLE);

                    reading_view.setText(readingStyle.compareTo("kana") == 0? result.getReading(): result.getRomajiReading());

                }

                // If pitch information is available, make it visible

                String pitch = result.getPitch();

                if(pitch != null) {

                    pitch_view.setVisibility(View.VISIBLE);

                    pitch_view.setText(pitch);

                    pitch_view.setOnClickListener(new View.OnClickListener() {

                        @Override

                        public void onClick(View v) {

                            Intent intent = new Intent(context, HelpPitchActivity.class);

                            context.startActivity(intent);

                        }

                    });

                }

                if(result.getAlternatives().size() > 1)

                    additional_info.setText(String.format(context.getResources().getString(R.string.sense_alternatives), getContent(result.getAlternatives())));

                else

                    additional_info.setVisibility(View.GONE);

                senses_view.removeAllViews();

                int sense_pos = 1;

                for (Result.Sense sense : result.getSenses()) {

                    View child = LayoutInflater.from(context).inflate(R.layout.layout_sense, senses_view, false);

                    TextView id_view = child.findViewById(R.id.id_view);

                    TextView lang_view = child.findViewById(R.id.lang_view);

                    TextView sense_view = child.findViewById(R.id.definition_view);

                    id_view.setText(String.format(context.getResources().getString(R.string.sense_number), sense_pos));

                    lang_view.setText(sense.getLanguage());

                    StringBuilder sb = new StringBuilder();

                    sb.append("<font color=\"#909090\"><i>");

                    sb.append(getContent(sense.getInfos()));

                    sb.append("</i></font>");

                    if(sense.getInfos().size() > 0)

                        sb.append(" ");

                    sb.append(getContent(sense.getGlosses()));

                    sense_view.setText(Html.fromHtml(sb.toString()));

                    senses_view.addView(child);

                    sense_pos++;

                }

                result_view.addView(child_result);

            }

        }

    }

    private LayoutInflater mInflater;

    ResultPagerAdapter(Context context) {

        this.mInflater = LayoutInflater.from(context);

        this.context = context;

    }

    @NonNull

    @Override

    public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {

        View view = mInflater.inflate(R.layout.fragment_results, parent, false);

        return new ViewHolder(view, context);

    }

    @Override

    public void onBindViewHolder(@NonNull ViewHolder holder, int position) {

        if(position == 0)

            holder.showResults();

        else

            holder.showKanjiResults();

    }

    @Override

    public int getItemCount() {

        return 2;

    }

    public void setReadingStyle(String readingStyle) {

        ResultPagerAdapter.readingStyle = readingStyle;

        Log.d(TAG, "reading style updated to " + readingStyle);

        notifyDataSetChanged();

    }

    public void setKanjiResults(List<KanjiResult> kanjiResults) {

        if(kanjiResults == null)

            return;

        ResultPagerAdapter.kanjiResults.clear();

        ResultPagerAdapter.kanjiResults.addAll(kanjiResults);

        Log.d(TAG, "kanjis: " + ResultPagerAdapter.kanjiResults.size());

        notifyDataSetChanged();

    }

    public void setResults(List<Result> results) {

        if(results == null)

            return;

        ResultPagerAdapter.results.clear();

        ResultPagerAdapter.results.addAll(results);

        Log.d(TAG, "results: " + ResultPagerAdapter.results.size());

        notifyDataSetChanged();

    }

}

import java.util.List;

import eu.lepiller.nani.result.KanjiResult;

    private List<Result> results;

    private List<KanjiResult> kanjiResults;

    SearchResult(List<Result> results, List<KanjiResult> kanjiResults, String text, boolean converted) {

        this.kanjiResults = kanjiResults;

    List<Result> getResults() {

    List<KanjiResult> getKanjiResults() {

        return kanjiResults;

    }

import java.util.Stack;

import eu.lepiller.nani.result.KanjiResult;

                        } else if (type.compareTo("kanjidic") == 0) {

                            d = new KanjiDict(name,

                                    chooseLanguage(synopsis),

                                    chooseLanguage(description),

                                    cacheDir, url, size, entries, sha256, lang);

    public static KanjiResult searchKanji(String kanji) throws DictionaryException {

        if(instance == null)

            throw new NoDictionaryException();

        int available = 0;

        Stack<KanjiResult> results = new Stack<>();

        for(Dictionary d: dictionaries) {

            if (d instanceof KanjiDict && d.isDownloaded()) {

                available++;

                KanjiResult kanjiResult = ((KanjiDict) d).search(kanji);

                if(kanjiResult != null) {

                    results.add(kanjiResult);

                }

            }

        }

        Log.d(TAG, "search kanji, " + results.size() + " results");

        if(results.size() == 0)

            return null;

        KanjiResult res = results.pop();

        for(KanjiResult r: results) {

            res.merge(r);

        }

        return res;

    }

            Log.v(TAG, "found trie value, reading values");

                long nextPos = file.readInt();

                Log.v(TAG, "Taking transition "+letter+" to " + nextPos);

                return searchTrie(file, nextPos, ntxt, decoder);

package eu.lepiller.nani.dictionary;

import android.util.Log;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import eu.lepiller.nani.R;

import eu.lepiller.nani.result.KanjiResult;

public class KanjiDict extends FileDictionary {

    final private static String TAG = "KANJIDIC";

    private Huffman readingHuffman, meaningHuffman;

    KanjiDict(String name, String description, String fullDescription, File cacheDir, String url, int fileSize, int entries, String hash, String lang) {

        super(name, description, fullDescription, cacheDir, url, fileSize, entries, hash, lang);

    }

    @Override

    public void remove() {

        super.remove();

        readingHuffman = null;

        meaningHuffman = null;

    }

    @Override

    int getDrawableId() {

        return R.drawable.ic_nani_edrdg;

    }

    KanjiResult getValue(RandomAccessFile file, long pos, String kanji) throws IOException {

        Log.d(TAG, "getValue at " + pos);

        file.seek(pos);

        int stroke = file.readByte();

        Log.d(TAG, "strokes: " + stroke);

        List<String> senses = getHuffmanStringList(file, meaningHuffman);

        List<KanjiResult.Sense> meanings = new ArrayList<>();

        for(String s: senses) {

            meanings.add(new KanjiResult.Sense(this.getLang(), s));

        }

        List<String> kun = getHuffmanStringList(file, readingHuffman);

        List<String> on = getHuffmanStringList(file, readingHuffman);

        List<String> nanori = getHuffmanStringList(file, readingHuffman);

        return new KanjiResult(kanji, stroke, meanings, kun, on, nanori);

    }

    KanjiResult search(final String kanji) throws IncompatibleFormatException {

        if (isDownloaded()) {

            try {

                Log.d(TAG, "search for kanji " + kanji);

                RandomAccessFile file = new RandomAccessFile(getFile(), "r");

                byte[] header = new byte[16];

                int l = file.read(header);

                if (l != header.length)

                    return null;

                // Check file format version

                if(!Arrays.equals(header, "NANI_KANJIDIC001".getBytes())) {

                    StringBuilder error = new StringBuilder("search: incompatible header: [");

                    boolean first = true;

                    for(byte b: header) {

                        if(first)

                            first = false;

                        else

                            error.append(", ");

                        error.append(b);

                    }

                    error.append("].");

                    Log.d(TAG, error.toString());

                    throw new IncompatibleFormatException(getName());

                }

                Log.d(TAG, "header OK");

                byte[] search = kanji.toLowerCase().getBytes();

                file.skipBytes(4); // size

                meaningHuffman = loadHuffman(file);

                readingHuffman = loadHuffman(file);

                long kanjiTriePos = file.getFilePointer();

                Log.d(TAG, "trie pos: " + kanjiTriePos);

                return searchTrie(file, kanjiTriePos, search, new TrieValsDecoder<KanjiResult>() {

                    @Override

                    public KanjiResult decodeVals(RandomAccessFile file1, long pos) throws IOException {

                        Log.d(TAG, "decoding val");

                        file1.seek(pos);

                        return getValue(file1, file1.readInt(), kanji);

                    }

                    @Override

                    public void skipVals(RandomAccessFile file1, long pos) throws IOException {

                        file1.seek(pos);

                        file1.skipBytes(4);

                    }

                });

            } catch (FileNotFoundException e) {

                e.printStackTrace();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

        return null;

    }

}

package eu.lepiller.nani.result;

import java.util.ArrayList;

import java.util.List;

public class KanjiResult {

    public static class Sense {

        private String lang, content;

        public Sense(String lang, String content) {

            this.lang = lang;

            this.content = content;

        }

        public String getContent() {

            return content;

        }

        public String getLang() {

            return lang;

        }

    }

    private String kanji;

    private int stroke;

    private List<Sense> senses;

    private List<String> on;

    private List<String> kun;

    private List<String> nanori;

    public KanjiResult(String kanji, int stroke, List<Sense> senses, List<String> kun, List<String> on, List<String> nanori) {

        this.kanji = kanji;

        this.stroke = stroke;

        this.senses = senses;

        this.kun = kun;

        this.on = on;

        this.nanori = nanori;

    }

    public List<String> addUniq(List<String> a, List<String> b) {

        List<String> res = new ArrayList<>();

        for(String s: a) {

            if(res.contains(s))

                continue;

            res.add(s);

        }

        for(String s: b) {

            if(res.contains(s))

                continue;

            res.add(s);

        }

        return res;

    }

    public void merge(KanjiResult other) {

        this.senses.addAll(other.senses);

        this.on = addUniq(this.on, other.on);

        this.on = addUniq(this.kun, other.kun);

        this.on = addUniq(this.nanori, other.nanori);

    }

    public List<Sense> getSenses() {

        return senses;

    }

    public int getStroke() {

        return stroke;

    }

    public List<String> getKun() {

        return kun;

    }

    public List<String> getNanori() {

        return nanori;

    }

    public List<String> getOn() {

        return on;

    }

    public String getKanji() {

        return kanji;

    }

}

            <LinearLayout

                <androidx.viewpager2.widget.ViewPager2

                    android:layout_height="match_parent"

                    android:id="@+id/pager" />

            </LinearLayout>

                <com.google.android.material.tabs.TabLayout

                    android:id="@+id/tab_layout"

                    android:text="???"

                    android:layout_gravity="center_vertical"/>

<?xml version="1.0" encoding="utf-8"?>

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical">

    <LinearLayout

        android:id="@+id/results_view"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:orientation="vertical" />

</ScrollView>

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="wrap_content"

    android:orientation="horizontal"

    android:layout_marginBottom="16dp">

    <LinearLayout

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:orientation="vertical"

        android:layout_gravity="center_vertical">

        <TextView

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:id="@+id/kanji_view"

            android:textSize="@dimen/title_size"

            android:layout_gravity="center"

            android:layout_marginLeft="8dp"

            android:layout_marginStart="8dp"

            android:layout_marginRight="8dp"

            android:layout_marginEnd="8dp" />

        <TextView

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:layout_gravity="center_horizontal"

            android:id="@+id/kanji_strokes" />

    </LinearLayout>

    <LinearLayout

        android:layout_width="0dp"

        android:layout_height="wrap_content"

        android:layout_weight="1"

        android:orientation="vertical">

        <LinearLayout

            android:orientation="vertical"

            android:id="@+id/sense_view"

            android:layout_width="wrap_content"

            android:layout_height="wrap_content">

        </LinearLayout>

        <TextView

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:layout_marginLeft="8dp"

            android:layout_marginStart="8dp"

            android:id="@+id/kun_reading" />

        <TextView

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:layout_marginLeft="8dp"

            android:layout_marginStart="8dp"

            android:id="@+id/on_reading" />

        <TextView

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:layout_marginLeft="8dp"

            android:layout_marginStart="8dp"

            android:id="@+id/nanori_reading" />

    </LinearLayout>

</LinearLayout>

    android:orientation="vertical"

    android:layout_marginBottom="8dp">

<?xml version="1.0" encoding="utf-8"?>

<ScrollView

    xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent">

    <LinearLayout

        android:id="@+id/results_view"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:layout_marginTop="16dp"

        android:layout_marginBottom="8dp"

        android:orientation="vertical" />

</ScrollView>

    <dimen name="text_margin">16dp</dimen>

    <string name="sense_separator" translatable="false">"???"</string>

    <string name="tab_kanji">Kanji</string>

    <string name="tab_results">Word</string>

    <plurals name="kanji_stroke">

        <item quantity="one">%d stroke</item>

        <item quantity="other">%d strokes</item>

    </plurals>

    <string name="kun_reading">kunyomi: %s</string>

    <string name="on_reading">onyomi: %s</string>

    <string name="nanori_reading">nanori: %s</string>

    <string name="large_text">

        "Material is the metaphor.\n\n"

        "A material metaphor is the unifying theory of a rationalized space and a system of motion."

        "The material is grounded in tactile reality, inspired by the study of paper and ink, yet "

        "technologically advanced and open to imagination and magic.\n"

        "Surfaces and edges of the material provide visual cues that are grounded in reality. The "

        "use of familiar tactile attributes helps users quickly understand affordances. Yet the "

        "flexibility of the material creates new affordances that supercede those in the physical "

        "world, without breaking the rules of physics.\n"

        "The fundamentals of light, surface, and movement are key to conveying how objects move, "

        "interact, and exist in space and in relation to each other. Realistic lighting shows "

        "seams, divides space, and indicates moving parts.\n\n"

        "Bold, graphic, intentional.\n\n"

        "The foundational elements of print based design typography, grids, space, scale, color, "

        "and use of imagery guide visual treatments. These elements do far more than please the "

        "eye. They create hierarchy, meaning, and focus. Deliberate color choices, edge to edge "

        "imagery, large scale typography, and intentional white space create a bold and graphic "

        "interface that immerse the user in the experience.\n"

        "An emphasis on user actions makes core functionality immediately apparent and provides "

        "waypoints for the user.\n\n"

        "Motion provides meaning.\n\n"

        "Motion respects and reinforces the user as the prime mover. Primary user actions are "

        "inflection points that initiate motion, transforming the whole design.\n"

        "All action takes place in a single environment. Objects are presented to the user without "

        "breaking the continuity of experience even as they transform and reorganize.\n"

        "Motion is meaningful and appropriate, serving to focus attention and maintain continuity. "

        "Feedback is subtle yet clear. Transitions are ef???cient yet coherent.\n\n"

        "3D world.\n\n"

        "The material environment is a 3D space, which means all objects have x, y, and z "

        "dimensions. The z-axis is perpendicularly aligned to the plane of the display, with the "

        "positive z-axis extending towards the viewer. Every sheet of material occupies a single "

        "position along the z-axis and has a standard 1dp thickness.\n"

        "On the web, the z-axis is used for layering and not for perspective. The 3D world is "

        "emulated by manipulating the y-axis.\n\n"

        "Light and shadow.\n\n"

        "Within the material environment, virtual lights illuminate the scene. Key lights create "

        "directional shadows, while ambient light creates soft shadows from all angles.\n"

        "Shadows in the material environment are cast by these two light sources. In Android "

        "development, shadows occur when light sources are blocked by sheets of material at "

        "various positions along the z-axis. On the web, shadows are depicted by manipulating the "

        "y-axis only. The following example shows the card with a height of 6dp.\n\n"

        "Resting elevation.\n\n"

        "All material objects, regardless of size, have a resting elevation, or default elevation "

        "that does not change. If an object changes elevation, it should return to its resting "

        "elevation as soon as possible.\n\n"

        "Component elevations.\n\n"

        "The resting elevation for a component type is consistent across apps (e.g., FAB elevation "

        "does not vary from 6dp in one app to 16dp in another app).\n"

        "Components may have different resting elevations across platforms, depending on the depth "

        "of the environment (e.g., TV has a greater depth than mobile or desktop).\n\n"

        "Responsive elevation and dynamic elevation offsets.\n\n"

        "Some component types have responsive elevation, meaning they change elevation in response "

        "to user input (e.g., normal, focused, and pressed) or system events. These elevation "

        "changes are consistently implemented using dynamic elevation offsets.\n"

        "Dynamic elevation offsets are the goal elevation that a component moves towards, relative "

        "to the component???s resting state. They ensure that elevation changes are consistent "

        "across actions and component types. For example, all components that lift on press have "

        "the same elevation change relative to their resting elevation.\n"

        "Once the input event is completed or cancelled, the component will return to its resting "

        "elevation.\n\n"

        "Avoiding elevation interference.\n\n"

        "Components with responsive elevations may encounter other components as they move between "

        "their resting elevations and dynamic elevation offsets. Because material cannot pass "

        "through other material, components avoid interfering with one another any number of ways, "

        "whether on a per component basis or using the entire app layout.\n"

        "On a component level, components can move or be removed before they cause interference. "

        "For example, a floating action button (FAB) can disappear or move off screen before a "

        "user picks up a card, or it can move if a snackbar appears.\n"

        "On the layout level, design your app layout to minimize opportunities for interference. "

        "For example, position the FAB to one side of stream of a cards so the FAB won???t interfere "

        "when a user tries to pick up one of cards.\n\n"

    </string>