* Application can now download dictionaries from Wadoku.

| [Wadoku](https://wadoku.de) | Wadoku | [Non-commercial license](https://www.wadoku.de/wiki/display/WAD/Wadoku.de-Daten+Lizenz) | Provides the main search function |

                                    cacheDir, url, size, entries, sha256);

                                    cacheDir, url, size, entries, sha256);

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

                            d = new WadokuResultDictionary(name,

                                    chooseLanguage(synopsis),

                                    chooseLanguage(description),

                                    cacheDir, url, size, entries, sha256);

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

                ArrayList<Result> dr = ((ResultDictionary) d).search(text);

        ResultDictionary.Huffman h = huffman;

            if(h instanceof ResultDictionary.HuffmanValue) {

                c = ((ResultDictionary.HuffmanValue) h).character;

            } else if(h instanceof ResultDictionary.HuffmanTree) {

                h = bo? ((ResultDictionary.HuffmanTree) h).right: ((ResultDictionary.HuffmanTree) h).left;

public class JMDict extends ResultDictionary {

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

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 eu.lepiller.nani.result.Result;

abstract public class ResultDictionary extends FileDictionary {

    final private static String TAG = "JMDICT";

    private Huffman kanjiHuffman, readingHuffman, meaningHuffman;

    ResultDictionary(String name, String description, String fullDescription, File cacheDir, String url,

                     int fileSize, int entries, String hash) {

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

    }

    @Override

    public void remove() {

        super.remove();

        kanjiHuffman = null;

        readingHuffman = null;

        meaningHuffman = null;

    }

    private Result getValue(RandomAccessFile file, long pos) throws IOException {

        file.seek(pos);

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

        ArrayList<String> kanjis = getHuffmanStringList(file, kanjiHuffman);

        Log.d(TAG, "Getting readings");

        ArrayList<Result.Reading> readings = new ArrayList<>();

        int reading_number = file.readShort();

        Log.d(TAG, reading_number + " readings.");

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

            ArrayList<String> reading_kanjis = getStringList(file);

            Log.d(TAG, "kanjis: " + reading_kanjis);

            ArrayList<String> reading_infos = getStringList(file);

            Log.d(TAG, "infos: " + reading_kanjis);

            ArrayList<String> reading_readings = getHuffmanStringList(file, readingHuffman);

            Result.Reading r = new Result.Reading(reading_kanjis, reading_infos, reading_readings);

            readings.add(r);

        }

        ArrayList<Result.Sense> senses = new ArrayList<>();

        int meaning_number = file.readShort();

        Log.d(TAG, meaning_number + " meanings.");

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

            ArrayList<String> sense_references = getStringList(file);

            ArrayList<String> sense_limits = getStringList(file);

            ArrayList<String> sense_infos = getStringList(file);

            ArrayList<Result.Source> sense_sources = new ArrayList<>();

            int source_number = file.readShort();

            for(int j=0; j<source_number; j++) {

                ArrayList<String> source_content = getStringList(file);

                boolean source_wasei = file.read() != 0;

                String source_type = getString(file);

                String source_language = getString(file);

                sense_sources.add(new Result.Source(source_content, source_wasei, source_type, source_language));

            }

            ArrayList<Integer> sense_tags = getIntList(file);

            ArrayList<String> sense_glosses = getHuffmanStringList(file, meaningHuffman);

            String sense_language = getString(file);

            senses.add(new Result.Sense(sense_references, sense_limits, sense_infos, sense_sources,

                    sense_tags, sense_glosses, sense_language));

        }

        return new Result(kanjis, readings, senses);

    }

    private ArrayList<Integer> getValues(RandomAccessFile file, long triePos) throws IOException {

        file.seek(triePos);

        Log.d(TAG, "Getting values");

        int valuesLength = file.readShort();

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

        Log.d(TAG, "Number of values: " + valuesLength);

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

            results.add(file.readInt());

        }

        int transitionLength = file.readByte();

        Log.d(TAG, "Number of transitions: " + transitionLength);

        int[] others = new int[transitionLength];

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

            file.skipBytes(1);

            others[i] = file.readInt();

        }

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

            results.addAll(getValues(file, others[i]));

        }

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

        return results;

    }

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

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

        Log.d(TAG, "Remaining transitions: " + new String(txt, encoding));

        file.seek(triePos);

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

        if(txt.length == 0) {

            return getValues(file, triePos);

        } else {

            int valuesLength = file.readShort();

            Log.d(TAG, "number of values: " + valuesLength);

            file.skipBytes(valuesLength * 4);

            int transitionLength = file.readByte();

            Log.d(TAG, "number of transitions: " + transitionLength);

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

                byte letter = file.readByte();

                Log.d(TAG, "Possible transition " + letter + "; Expected transition: " + txt[0]);

                if(letter == txt[0]) {

                    Log.d(TAG, "Taking transition "+letter);

                    byte[] ntxt = new byte[txt.length-1];

                    System.arraycopy(txt, 1, ntxt, 0, txt.length-1);

                    return searchTrie(file, file.readInt(), ntxt);

                } else {

                    file.skipBytes(4);

                }

            }

            return null;

        }

    }

    ArrayList<Result> search(String text) throws IncompatibleFormatException {

        if (isDownloaded()) {

            try {

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

                byte[] header = new byte[14];

                int l = file.read(header);

                if (l != header.length)

                    return null;

                // Check file format version

                if(!Arrays.equals(header, "NANI_JMDICT001".getBytes()))

                    throw new IncompatibleFormatException(getName());

                byte[] search = text.getBytes();

                long kanjiTriePos = file.readInt();

                long readingTriePos = file.readInt();

                long meaningTriePos = file.readInt();

                Log.d(TAG, "Search in: " + getFile());

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

                Log.d(TAG, "reading: " + readingTriePos);

                Log.d(TAG, "meaning: " + meaningTriePos);

                kanjiHuffman = loadHuffman(file);

                readingHuffman = loadHuffman(file);

                meaningHuffman = loadHuffman(file);

                logHuffman(readingHuffman, new ArrayList<Boolean>());

                // Search in Japanese, by kanji and reading

                ArrayList<Integer> results = searchTrie(file, kanjiTriePos, search);

                ArrayList<Integer> readingResults = searchTrie(file, readingTriePos, search);

                if(results != null && readingResults != null)

                    results.addAll(readingResults);

                else if (results == null)

                    results = readingResults;

                // Search in other language, by meaning

                if(results == null || results.isEmpty())

                    results = searchTrie(file, meaningTriePos, search);

                if(results == null || results.isEmpty())

                    return null;

                ArrayList<Result> r = new ArrayList<>();

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

                for(Integer i: results) {

                    if(!uniqResults.contains(i))

                        uniqResults.add(i);

                }

                int[] uniqResultsArray = new int[uniqResults.size()];

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

                    uniqResultsArray[i] = uniqResults.get(i);

                }

                Arrays.sort(uniqResultsArray);

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

                int num = 0;

                for(int i: uniqResultsArray) {

                    if(num > 10)

                        break;

                    num++;

                    r.add(getValue(file, i));

                }

                return r;

            } catch (FileNotFoundException e) {

                e.printStackTrace();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

        return null;

    }

}

package eu.lepiller.nani.dictionary;

import java.io.File;

import eu.lepiller.nani.R;

public class WadokuResultDictionary extends ResultDictionary {

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

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

    }

    @Override

    int getDrawableId() {

        return R.drawable.wadoku;

    }

}

        <TextView

            android:id="@+id/textView21"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            android:layout_marginTop="16dp"

            android:text="@string/wadoku_title"

            android:textColor="@color/design_default_color_primary_dark"

            android:textSize="@dimen/subtitle_size" />

        <TextView

            android:id="@+id/textView22"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            app:lineHeight="22dp"

            android:text="@string/wadoku_descr" />

        <TextView

            android:id="@+id/textView23"

            android:layout_width="match_parent"

            android:layout_height="wrap_content"

            app:lineHeight="22dp"

            android:text="@string/wadoku_license" />

    <string name="wadoku_title">Wadoku.de</string>

    <string name="wadoku_descr">Le projet wadoku, cr???? en l\'an 2000, est un dictionnaire

        japonais/allemand. Son but est de cr??er une liste de vocabulaire en priorisant les nouveaux

        termes et les sujets de recherche. C\'est l\'un des dictionnaires japonais/allemand les plus

        complets.</string>

    <string name="wadoku_license">Ces donn??es sont disponibles gratuitement, sous une licence

        non-commerciale. Nous l\'utilisons parce que cette appli est gratuite et n\'affiche pas

        de publicit??. Nous avons appliqu?? des changements ?? la base de donn??es pour la convertir en

        notre format interne, en accord avec la licence. Voir

        https://www.wadoku.de/wiki/display/WAD/Wadoku.de-Daten+Lizenz pour le texte complet de

        la licence.</string>

    <string name="wadoku_title">Wadoku.de</string>

    <string name="wadoku_descr">The Wadoku project was created in 2000 as a free German/Japanese

        dictionary. It goal is to create a vocabulary set with a focus on new terms and research

        subjects. It is one of the most comprehensive German/Japanese dictionaries.</string>

    <string name="wadoku_license">This data is available for free download, under a non-commercial

        license.  We can use it because this app is free and does not display ads.  We have applied

        changes to the database to convert it to our internal format, in accordance with the license

        agreement.  See https://www.wadoku.de/wiki/display/WAD/Wadoku.de-Daten+Lizenz for the full

        text of the license.</string>