• Become a beta tester
• Translate AnkiDroid into your language
• Other Non-developer tasks
• Source code
• Compiling with Eclipse
• Debugging in Eclipse
• Compiling with Ant (optional)
• Other development tools
• Submit improvements
• Checking database modifications
• To do from time to time
• Development cycle
• How to sponsor development
• Modifying the AnkiDroid -triage tool
• Markets
• Administration
• Other open source Android flashcards apps
• Contributors

Become a beta tester

Please see the AnkiDroid manual for how to become a beta tester.

Translate AnkiDroid into your language

Even if you prefer to use AnkiDroid in English, other people in your country might prefer to use it in their own language. Translating AnkiDroid to your native language means your country's AnkiDroid will grow much faster, leading to better shared decks in your language.

Translating is easy and fun:

• Go to http://crowdin.net/project/ankidroid
• Register, if you don't have an account yet
• Click on the flag of your language
• Click on a file (they are sorted by descending priority)
• Click on "Sort"
• Click on "Missing translation"
• Grey bullet=missing, Green bullet=done
• Terms like "%s", "%1$d" are placeholders for strings or numbers which will be filled later by AnkiDroid. They must not be changed, e.g. reversed ("1%d2") or filled with spaces ("% s").

For each grey bullet, translate the English text to your language. For terms like "fact" or "leech", see how they are translated in Anki Desktop. If you don't have Anki on any computer, see here.

Logic of the separation in different files

• android_market.xml : Text seen by Android users who see AnkiDroid in the Market, and are pondering whether to install it or not.
• 01-core.xml : Most important strings (reviewer, studyoptions, deckpicker)
• 02-strings.xml: Strings which are nice to have but are not immediately visible when learning
• 03-dialogs.xml: Texts for dialogs (warnings, information etc.)
• 04-network.xml: Strings for syncing and downloading decks
• 05-feedback.xml: Strings for feedback system
• 06-statistics.xml: Strings for all statistics
• 07-cardbrowser.xml: Strings for card browser
• 08-widget.xml: Strings for widget
• 09-backup.xml: Strings for backup system
• 10-preferences.xml: Strings which are used in the preferences screens
• 11-arrays.xml: Array-Strings which are used in the preferences screens

Switching the language of the AnkiDroid UI

• Go to the decks list
• Menu > Preferences (1st item) > Language (6th item) > Language (1st item)
• Select the language you want

Translating the AnkiDroid manual

The source for the AnkiDroid manual can be found on the ankidroiddocs github page. The manual is written in a plain text markup language called asciidoctor which is very easy to use. The asciidoctor file is called "manual.txt" and it can be compiled to html as follows:

First install Asciidoctor:

• Install Ruby
• Open command prompt with Ruby
• Enter the command gem install asciidoctor

Then compile the manual as follows:

• Open command prompt with Ruby
• Enter the command asciidoctor FULL_PATH_TO_SOURCE_FILE
• A file will be generated with the same name as the source file, but with .html extension.

The preferred method of contributing to the documentation is to fork the ankidroiddocs project on github, and send a pull request with your additions in the usual way. However, if you don't know how to use github, you can simply download the "manual.txt" file and send it to a project member or the Google Group.

To create a translation of the manual, please make a copy of "manual.txt" and add "-LANUGAGE_CODE". For example for Italian submit a translated file called "manual-it.txt" based on the original source file.

Translations should be periodically updated to reflect any changes in the original manual. Details of all changes can be found in the list of commits on github.

Take screenshots

For each language we need:

• A few screenshots on a normal phone (review with image, review with sound, card edition, deck list)
• At least one screenshot on a ~7inch screen
• At least one screenshot on a ~10inch screen

Here are all screenshots we have, so you can see which ones are missing: https://github.com/ankidroid/Anki-Android/tree/v2.0.2-dev/docs/marketing/screenshots

Send the images to the forum so that we can use them to improve the Play Store page, the Wiki, etc.

You can download various shared decks to show nice content. To take a screenshot, press the "Power" and "Volume down" buttons simultaneously. You can use the emulator if you don't have any 7inch or 10inch device.

To take screenshots for several languages, you can switch the AnkiDroid UI language in Preferences as explained above.

Other Non-developer tasks

• Send us your ManualTesting results about the alphas/betas.
• Blog about AnkiDroid and spread the word :-)
• Follow us on Twitter and Facebook.
• Sort the crash reports with AnkiDroidTriage.
• Here is a list of tasks that can be done by people who can't code.

Source code

First, register at Github.com, open AnkiDroid github repository and follow the forking instructions.

If you want to be notified about each new improvement/bugfix, please subscribe to the commits feed for the development branch.

Branching Model

We use the gitflow branching model, so "develop" (the default branch) contains the latest development code, whereas "master" contains the code for the latest stable release. When we move into the "beta" phase of the development cycle, we implement a feature freeze, and a temporary branch "release-N.n" (N.n being the version code) is created which is only for important bug fixes. During this period, changes to "release-N.n" are regularly merged back into the "develop" branch so that it doesn't fall behind. If an urgent bug is discovered shortly after a major release, a special "hotfix-N.n" branch will be created from master.

In most cases you should base your code on and send pull requests to the default "develop" branch. However, if you are working on a critical bug fix during the feature freeze period or for a hot-fix, you should use the "release-N.n" or "hotfix-N.n" branch. If you are unsure which branch to use, please ask on the forum.

Compiling with Eclipse

If it is your first time developing for Android, please follow these instructions. If you already have an environment set up, ensure the SDK tools are up to date. To do this, go to Window -> Android SDK Manager and check if the items under the Tools folder need updates.

In order to open the codebase as an Eclipse project, after you have followed the Android environment setup instructions at the link above, follow these steps:

• File -> New -> Project ...
• Select the "Android Project from Existing Code" option in the "New Project" dialog and click next.
• Set the "root directory" field to your local directory containing the source code. Note: The directory from which you import the source must not already be in your Eclipse workspace.
• Be sure to select all packages in that directory; e.g. "android-support-v7-appcompat", "AnkiDroid", "AnkiDroid-Tests", etc.
• Click "Finish".
• Set the default encoding to UTF-8 to avoid mojibake: Go to Window > Preferences > General > Content types and set the default encoding to "UTF-8" for text files, most importantly for Java source files and XML files.
• In the Preferences window, go to General >Workspace and set the Text file encoding from Default to Other and pick UTF-8 from the dropdown. Close the window with "OK".
• Next import the AnkiDroid code conventions (this is important as it sets things like correct indentation settings): Go to Project > Properties > Java > Code Style and for each of ("Clean Up", "Formatter", and "Organize Imports") click "Enable project specific settings", then click "import", and choose the correspondingly named file from the repository's docs/code_conventions/eclipse folder.
• While you've got the project properties window open, go to project properties > java compiler > and check that "Compiler compliance level" is set to 1.6. The project must target java 1.6, and lower java runtimes will complain about @Override annotated method's "must override superclass method".
• Click "OK". The project should be up and running in Eclipse!
• To run in the Android Emulator, create a new Android virtual device in the "Window -> Android Virtual Device Manger" screen. It is recommend to test using Android 2.1, which is the minimum required version for AnkiDroid (be sure to allocate some memory for the SD card).
• After running in the emulator, the compiled apk can be found in the "bin" directory of the project. This apk is signed with the default debug key, so that it can be installed on a device. An unsigned APK (which will be uninstallable) can be generated as per this link.

Note: A change was made to AnkiDroid in October 2014 which requires the creation of a brand new Eclipse project. If you have an existing AnkiDroid project in Eclipse from before this time, please delete it and follow the above instructions again to create a new project

Debugging in Eclipse

To start debugging, in the package explorer, right-click on AnkiDroid and choose Debug As -> Android Application, then select a device to run on (it can be a virtual device, or a real physical Android device). You should now be able to be stop at any break points in the program.

Alternatively, you can start debugging after the program has already started running by opening the DDMS view (Window -> Open Perspective -> Other -> DDMS), then find the com.ichi2.anki process in the devices window, and click on the green debug icon:

Compiling with Ant (optional)

(If you use Eclipse you can skip this step)

• In the top level directory, create a "local.properties" file containing the path to the Android SDK, for instance:

sdk.dir=/home/nico/programs/android-sdk

• Plug in your Android phone via USB and run the following commands (replace ".sh" with ".bat" if on Windows):

./create-build-files.sh
ant debug
ant installd

Other development tools

A tool like "SQLite Database Browser" is very useful to understand how a ".anki" file is made, and to test SQL queries. To install it on Ubuntu:

sudo apt-get install sqlitebrowser

Submit improvements

Once you have improved the code, commit it and send a pull request to AnkiDroid Github Repository. It will then be accepted after the code has been reviewed, and the enhanced application will be available on the Android Market on the next release. See the branching model section if you are unsure which branch to push to.

If you have trouble with Git, you can send your modifications as an attachement to a bug in the issue tracker, or just paste the changed files as text to the forum.

Checking database modifications

On Ubuntu Linux:

• Install sqlite3 and meld: sudo apt-get install sqlite3 meld
• Make sure my desktop and android have about the same clock time.
• Copy country-capitals.anki to both
• Perform the same review sequence on both at the same time.
• Copy the modified decks for comparizon.
• Run:

echo .dump | sqlite3 country-capitals.desktop.anki >desktop.dump
echo .dump | sqlite3 country-capitals.android.anki >android.dump
diff desktop.dump android.dump > desktop-android.diff
meld desktop.dump android.dump

• Check that time are not too different, and notice any other difference.

To do from time to time

In addition to bugs and enhancements, here are a few things that someone or another should perform once in a while, maybe every month or so:

Download localized strings

• Go to the "tools" directory
• Run manage-crowdin.py
• Select "r" to build new packages
• Run update-localizations.py
• Commit and push

Licenses

• Check that all files mention the GNU-GPL license.
• Add it to those who don't.

Alternative markets

• Check whether the versions are AnkiDroid's latest release. If not, contact the person responsible for this Market.
• Look for new alternative markets (especially in non-English languages) and upload there (please update the Wiki then).

Development cycle

How to sponsor development

In case you are willing to pay money for a feature or fix to be implemented, here is how to do:

1. Create an issue if an issue asking for the same thing does not exist yet.
2. Add as many details as you can, describing how it could work, drawing a prototype on paper, etc.
3. Make sure the "Priority" value of the issue is reasonably high.
4. Post a comment asking "If I provide a good quality patch for this feature, will it be merged?" and wait for our answer.
5. Choose someone to do the job. Use any crowdsourcing platform you trust, or a developer friend, or a even software company. Experience with Android and Git are probably required.

Reach an agreement with the developer:

1. Agree with the developer on the conditions, defining exactly what they must implement.
2. Insist that produced source code must be released as Open Source (not doing so would be a breach of the GNU-GPLv3 license). A common error would be to ask only for the APK (which will quickly get out-of-date and incompatible)
3. If possible, make it a condition that produced source code must be merged by us before total payment. Or make it half/half. If the issue is Enhancement-Critical or Defect-High or Defect-Critical, then the developer can be assured that we will merge it fast, if the code is good enough.
4. Propose to become a tester if they need. Giving your feedback early could help. Be sure to test on different devices and in different scenarios.

Summary of the workflow:

Modifying the AnkiDroid-triage tool

Note: This paragraph describes how to modify to triage tool. Most developers do not need to bother with this.

The database can be read/modified here if Kostas has given you the rights: Main page Recent crashes Feedback

Anyone can download and contribute to the source of AnkiDroid-triage, which is at https://github.com/iniju/ankidroid-triage

Testing AnkiDroid-triage on Ubuntu 2010.10

Google AppEngine needs Python 2.5 and Ubuntu 2010.10's stock Python 2.6.6 won't do so go download it.

Install header files for SQLite3: sudo apt-get install libsqlite3-dev

Uncompress the downloaded Python 2.5 archive (for instance as ~/programs/python2.5), enter the directory and run: ./configure"

It should take a few seconds, then run: make

It will take about 30 seconds.

Download Django 1.1.4, unarchive it, and copy its "django" directory to the "Lib" directory of Python 2.5

Download the latest AppEngine SDK for Python and unarchive it (for instance as ~/programs/google_appengine).

Fork or download AnkiDroid-triage and put it at the root of AppEngine (for instance ~/programs/google_appengine/ankidroid-triage)

From AppEngine's directory, run: ~/programs/python2.5/python ankidroid-triage

Open a browser to http://localhost:8080 and you should see something similar to this except it contains zero crashes.

Markets

Administration

Read ReleaseProcedure for some insight on how AnkiDroid is released.

LocalizationAdministration describes how Crowdin is managed under the hood.

Other open source Android flashcards apps

We are on very friendly terms with other app creators, and some have already re-used AnkiDroid's code. Feel free to compare apps and transfer one's strong points to the other(s) when applicable:

• AnyMemo
• Android Flashcards
• Kanji Flashcards Android

Contributors

Many thanks to all of the people and companies who contributed to AnkiDroid! :

• A hundred people are working on the code, some sending just one patch, some becoming very involved.
• Simplified Chinese translation by / 简体中文版 安智网汉化 http://goapk.com
• Tens of anonymous translation contributors
• Hundreds of people are participating in the forum
• And thanks to the hundreds of thousands of AnkiDroid users!

We are very welcoming and open, please join us!