import androidx.appcompat.widget.Toolbar;

import androidx.swiperefreshlayout.widget.SwipeRefreshLayout;

import android.view.View;

import android.widget.AdapterView;

import android.widget.ListView;

public class DictionaryActivity extends AppCompatActivity {

    static final int DICO_REQUEST = 1;

    DictionariesAdapter adapter;

    ArrayList<Dictionary> dictionaries;

                if(connection.getResponseCode() == HttpURLConnection.HTTP_OK) {

                    InputStream input = connection.getInputStream();

                    File file = DictionaryFactory.getListFile();

                    byte[] data = new byte[4096];

                    FileOutputStream output = new FileOutputStream(file);

                    while((count = input.read(data)) != -1) {

package eu.lepiller.nani;

import android.app.NotificationManager;

import android.graphics.drawable.Drawable;

import android.os.AsyncTask;

import android.os.Build;

import android.util.Log;

import android.util.Pair;

import android.view.View;

import android.widget.ImageView;

import android.widget.LinearLayout;

import android.widget.ProgressBar;

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_dictionary_download);

        d = DictionaryFactory.get(position);

                    if(connection.getResponseCode() == HttpURLConnection.HTTP_OK) {

                        input = connection.getInputStream();

                        file = new File(cacheFile + ".sha256");

                        File old_file = new File(file + ".old");

                        if(old_file.exists()) {

                        }

                        if(file.exists()) {

                        }

                        output = new FileOutputStream(file);

                        while((count = input.read(data)) != -1) {

                                d.remove();

                            }

                        }

                    }

                    // .sha256 file now downloaded

                    url = new URL(uri);

                    file = temporaryFile;

                    long expectedLength = -1;

                    boolean acceptRanges = false;

                    if(file.exists()) {

                            acceptRanges = connection.getHeaderFields().containsKey("accept-ranges");

                            if (acceptRanges) {

                                List<String> headers = connection.getHeaderFields().get("accept-ranges");

                                }

                            }

                            Log.d(TAG, "Can do range? " + acceptRanges);

                    "Nani's dictionary download notification", NotificationManager.IMPORTANCE_DEFAULT);

            NotificationManager manager =

                    (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

        }

        PreferenceManager.setDefaultValues(this, R.xml.preferences, false);

            });

        }

        savedResults = searchResult;

    }

    void showResults(ArrayList<Result> searchResult) {

package eu.lepiller.nani;

import android.content.Context;

import android.os.AsyncTask;

import android.os.Build;

import android.util.AttributeSet;

import com.google.android.flexbox.FlexWrap;

import com.google.android.flexbox.FlexboxLayout;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.Set;

public class RadicalSelectorView extends LinearLayout implements OnTaskCompleted<Map<Integer, List<String>>>,

        OnOtherTaskCompleted<Pair<Map<Integer, List<String>>, Set<String>>> {

    private Button close_button;

    private LinearLayout kanji_row1, kanji_row2;

    private LinearLayout radical_table;

    public RadicalSelectorView(Context context, AttributeSet attrs, int defStyle) {

        super(context, attrs, defStyle);

        LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

        inflater.inflate(R.layout.content_radicals, this);

        this.setOrientation(VERTICAL);

    }

        resizeRadicals();

    }

        return radSize / 8;

    }

        for (int stroke : radicals.keySet()) {

            TextView strokeView = new TextView(getContext());

            radical_table.addView(strokeView);

            FlexboxLayout box = new FlexboxLayout(getContext());

            radical_table.addView(box);

            List<String> lst = radicals.get(stroke);

            for (final String radical : lst) {

                ToggleButton radicalButton = new ToggleButton(getContext());

                radicalButton.setTextOff(radical);

        @Override

        protected Pair<Map<Integer, List<String>>, Set<String>> doInBackground(String... sInput) {

            try {

                return new Pair<>(dict.match(radicals), dict.availableRadicals(radicals));

            } catch (IncompatibleFormatException e) {

                e.printStackTrace();

        int total = 0;

        int number = 0;

        for (int stroke : kanji.keySet()) {

        }

        for (int stroke : kanji.keySet()) {

            TextView strokeView = new TextView(getContext());

            strokeView.setLayoutParams(new LayoutParams(66, 66));

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {

                strokeView.setTextColor(getContext().getColor(R.color.colorAccent));

            }

            row.addView(strokeView);

                number++;

                Button kanji_button = new Button(getContext());

                kanji_button.setText(k);

import eu.lepiller.nani.dictionary.DictionaryException;

import eu.lepiller.nani.result.Result;

    private ArrayList<Result> results;

    private DictionaryException exception;

    private boolean converted;

import androidx.fragment.app.Fragment;

import androidx.preference.PreferenceFragmentCompat;

/**

 * A simple {@link Fragment} subclass.

 */

import android.widget.ImageView;

import android.widget.TextView;

import java.text.NumberFormat;

import java.util.ArrayList;

import eu.lepiller.nani.R;

public class DictionariesAdapter extends ArrayAdapter<Dictionary> {

    public DictionariesAdapter(Context context, ArrayList<Dictionary> dictionaries) {

        super(context, 0, dictionaries);

        this.context = context;

    }

        // Get the data item for this position

        Dictionary dictionary = getItem(position);

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

        Drawable icon = dictionary.getDrawable(context);

        if(icon != null) {

            icon_view.setImageDrawable(icon);

        }

import android.content.Context;

import android.graphics.drawable.Drawable;

import android.os.Build;

import android.util.Pair;

import androidx.vectordrawable.graphics.drawable.VectorDrawableCompat;

import java.io.FileReader;

import java.io.IOException;

import java.math.BigInteger;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.Map;

    private int expectedFileSize;

    private int expectedEntries;

    private String sha256;

    Dictionary(String n, String descr, String fullDescr, File cacheDir, int fileSize, int entries, String hash) {

        name = n;

    public int getExpectedFileSize() {

        return expectedFileSize;

    }

        return expectedEntries;

    }

        return sha256;

    }

    abstract public boolean isUpToDate();

    abstract public int size();

    public abstract Map<String, Pair<File, File>> getDownloads();

    public Drawable getDrawable(Context context) {

    public static String readSha256FromFile(File file) throws IOException {

        StringBuilder sb = new StringBuilder();

        FileReader fr = new FileReader(file);

        int count;

        while((count = fr.read(data)) != -1) {

        return sb.toString().trim();

    }

        MessageDigest digest=null;

        try {

            digest = MessageDigest.getInstance("SHA-256");

        } catch (NoSuchAlgorithmException e) {

            e.printStackTrace();

        }

        digest.reset();

        try {

            FileInputStream fr = new FileInputStream(file);

            int count;

            while((count = fr.read(data)) != -1) {

import android.content.Context;

import android.os.Build;

import android.os.LocaleList;

import android.util.Log;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.util.Locale;

import java.util.Map;

import eu.lepiller.nani.result.Result;

public class DictionaryFactory {

    private static String chooseLanguage(Map<String, StringBuilder> data) {

        for(String l: languages) {

        }

        return null;

    }

import java.util.Map;

public abstract class FileDictionary extends Dictionary {

    interface Huffman {

    }

    public void switchToCacheFile() {

        if(checkTemporaryFile()) {

            if(getFile().exists()) {

            }

        }

    }

            File sha256 = new File(getFile() + ".sha256");

            if(sha256.exists()) {

                String hash = sha256OfFile(f);

                try {

                    String expected = readSha256FromFile(sha256);

    }

    @Override

    public Map<String, Pair<File, File>> getDownloads() {

        HashMap<String, Pair<File, File>> result = new HashMap<>();

        Pair<File, File> pair = new Pair<>(getTemporaryFile(), getFile());

    @Override

    public void remove() {

        if(getFile().exists())

        if(getTemporaryFile().exists())

    }

        for(int j=0; j<bs.size(); j++) {

            str[j] = bs.get(j);

        }

    }

    ArrayList<String> getStringList(RandomAccessFile file) throws IOException {

        ArrayList<Integer> results = new ArrayList<>();

        int number = file.readShort();

        for(int i=0; i<number; i++) {

        }

        return results;

    }

            for(int i=0; i<bs.size(); i++) {

                array[i] = bs.get(i);

            }

        }

    }

        StringBuilder b = new StringBuilder();

        ArrayList<Boolean> bits = new ArrayList<>();

        String c = null;

package eu.lepiller.nani.dictionary;

public class IncompatibleFormatException extends DictionaryException {

        this.name = name;

    }

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.util.ArrayList;

import java.util.Arrays;

import eu.lepiller.nani.R;

import eu.lepiller.nani.result.Result;

    private ArrayList<Integer> searchTrie(RandomAccessFile file, long triePos, byte[] txt) throws IOException {

        Log.d(TAG, "searchTrie: " + triePos);

        file.seek(triePos);

        Log.d(TAG, "pointer: " + file.getFilePointer());

        if(txt.length == 0) {