OppiaMobile Documentation

OppiaMobile Documentation
OppiaMobile Documentation
Release 0.10.0
Alex Little, Digital Campus
Mar 01, 2018
OppiaMobile Key Features
Installation, Upgrading and Development
Creating your course in Moodle
Dashboard Guide
Points and Badges
OppiaMobile Training and Support
Content Adaptation
10 Getting Help
11 Acknowledgements
OppiaMobile Documentation, Release 0.10.0
OppiaMobile is the mobile learning platform from Digital Campus. This documentation details how to set up your
own implementation and how you may make basic customisations.
OppiaMobile Documentation, Release 0.10.0
OppiaMobile Key Features
1.1 For Learners
• Access learning activities, videos and quizzes all offline on Android smartphones
• Activities designed to support face-to-face training sessions
• Earn points and badges for completing activities and courses
• Automatic notification when course updates are available
• Multilingual content is supported
• Text to speech function – so activities can be read out loud
• Search course and activity content
1.2 For Tutors/Trainers/Supervisors
• Designed to support existing training and teaching programmes in all professional areas
• Track the activity and progress of your students – for example which activities they have completed, quiz scores
and videos watched
1.3 For Course Authors
• Supports learning/training content for any professional area
• Course content can be collaboratively edited and produced in Moodle – no need for programmers to maintain
and update learning content
• Updates to courses can be automatically pushed out to users
OppiaMobile Documentation, Release 0.10.0
1.4 For Administrators/Project Managers
• Designed to support existing training and teaching programmes in all professional areas
• Online dashboard to get a quick and easy overview of activities
• All code for both phone client app and server is open source – so you can customize to fit your needs
Chapter 1. OppiaMobile Key Features
Installation, Upgrading and Development
For installing OppiaMobile server and Moodle block please refer to:
OppiaMobile Documentation, Release 0.10.0
2.1 OppiaMobile Platform Architecture and Components
2.1.1 Architecture and Workflow
1. Courses are authored in Moodle.
2. When the course is exported from Moodle, the quizzes are automatically exported to the OppiaMobile server.
3. After export from Moodle, the module zip package can be downloaded and then uploaded into the learning modules app in the OppiaMobile server. The reason for leaving this as a manual upload (rather than automatically
published) is to allow content authors the option to test out the content on their devices before it is pushed out
as an automatic update to learners.
4. Our OppiaMobile server provides the core of the server side, dealing with all user accounts, modules, quiz result
submission and tracking activity.
5. When users install the OppiaMobile Android app, their accounts are created on the OppiaMobile server. All
quiz attempts and results are submitted from the OppiaMobile Android app to the OppiaMobile engine (when
the user has an internet connection available).
6. All learning modules are downloaded from the OppiaMobile server and all tracking activity by the user (pages
viewed, videos watched and quiz attempts) is submitted to the OppiaMobile server by the OppiaMobile Android
app. The OppiaMobile server also deals with all the points and badges awarded.
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
7. The OppiaMobile Android app delivers the learning content on the users phone.
8. Media and video content can be hosted on any website, providing it allows a direct download of the video
file. Currently all the media content is hosted in a static directory structure on our demo OppiaMobile website
(http://downloads.digital-campus.org/media/) – but this is only for convenience, rather than a requirement.
9. The OppiaMobile Android app can download the videos from the media hosting (if a wifi connection is available). Alternatively the media files may be directly copied onto the phone SD card.
2.1.2 Components Source Code
OppiaMobile Android App
The app is compatible with Android API level 14+ (i.e. Android version 4+).
• Source code: https://github.com/DigitalCampus/oppia-mobile-android
• Bug/issue tracker: https://github.com/DigitalCampus/oppia-mobile-android/issues
OppiaMobile Server
Provides the core server-side, using the Django framework.
• Source code: https://github.com/DigitalCampus/django-oppia
• Bug/issue tracker: https://github.com/DigitalCampus/django-oppia/issues
OppiaMobile Moodle block
A Moodle block (script) to export the course from Moodle into the right format for installing in the OppiaMobile
Android app.
• Source code: https://github.com/DigitalCampus/moodle-block_oppia_mobile_export
• Bug/issue tracker: https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/issues
2.2 OppiaMobile Development Roadmap
2.2.1 Short term
• Update to Django 1.11 LTS as support for the current version (1.8 LTS) will end in April 2018 (see: https:
• Improved and more intuitive way to embed video/audio content. Requires updates to Moodle block and Oppia
• Adding more comprehensive (automated) release testing process.
2.2.2 Medium term
• Restricting course access to particular users - for example where Oppia may be used for paid courses
• Offline data transfer - e.g. downloading usage activity from phone to computer for subsequent upload to server
• Improved gamification and linking up to OpenBadges, including gamification working offline
2.2. OppiaMobile Development Roadmap
OppiaMobile Documentation, Release 0.10.0
• Linking up to xAPI and learning record store
• Integration with data collection platforms (eg OpenSRP) - being able to launch particular learning activities
within the data platform, then also being able to match up data/accounts from Oppia and external platforms.
2.2.3 Long term
• Adaptive learning content and quizzes
• Improved teacher/supervisor tools
• Integration with messaging platforms (e.g. WhatsApp, Telegram)
2.3 Installation
To install and run the OppiaMobile server, you will need to be familiar with how to set up, install and maintain Django
applications. To learn how to get started with Django, visit http://www.gettingstartedwithdjango.com/.
• Create a virtual environment for python. We recommend that you use virtualenv to sandbox your python libraries
from others on your server.
• Create a fork of the django-oppia repository on Github and check this out to your server. For more information
on how to fork a repository in GitHub, see: https://help.github.com/articles/fork-a-repo/
• Run python setup.py develop to install the dependencies
• Add oppia to your installed INSTALLED_APPS like this:
• Edit your Django settings.py file as follows:
– Add:
import os,sys
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
PROJECT_PATH = os.path.normpath(os.path.join(BASE_DIR, '..', 'django-oppia
if PROJECT_PATH not in sys.path:
sys.path.insert(0, PROJECT_PATH)
replacing django-oppia with the name of your fork in github and referencing the location on your
server where you have cloned the repository
– Add the following code:
from oppia import local_settings_live
– Ensure you have the following standard Django settings configured:
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
– Add a new setting COURSE_UPLOAD_DIR, this should a read/writable
directory by your webserver user, for example:
COURSE_UPLOAD_DIR = '/home/uploads/'
This directory will store any uploaded courses, but it should not be web accessible (the server app
will control access to the downloads)
• Include the oppia URLconf in your project urls.py like this:
url(r'^', include('oppia.urls')),
It is expected that you would like the app running from the root of your domain name. If this is not the case,
then you can alternatively use:
url(r'^oppia/', include('oppia.urls')),
However, you may need to change some of the LOGIN_EXEMPT_URLS in the local_settings.py file
• Run python manage.py migrate to create the oppia models.
• Run python manage.py collectstatic this will copy all the required javascript, images, css and other
static files are copied to your STATIC_ROOT
• Run python manage.py createsuperuser to create the admin user for your site
• Run python manage.py loaddata default_badges.json this will create the default badges in
your database.
• Your OppiaMobile server should now be up and running: http://localhost:8000/ (or at http://localhost:8000/oppia
depending on how you configured your urls.py file)
• Finally, contribute! If you find issues and have fixed them, then please send us a pull request to integrate into
the core server code so everyone can benefit. If you find an issue, but aren’t sure how to fix it, then please file
an issue on Github
2.3.1 Cron
You should set up a cron task to run the oppia/cron.py script regularly. This script tidies up the course download
directory of temporary download files and also checks which course badges should be awarded.
• Exactly how you call cron.py will depend on your environment, but as an example on our development server
(and using virtualenv) we use a wrapper shell script with the following content:
cd /home/alex/data/development/oppia_core/env/ # <- path to virtualenv
source bin/activate # <- activate the virtualenv
PYTHONPATH="${PYTHONPATH}:/home/alex/data/development/" # <- path to Django
˓→project root
export DJANGO_SETTINGS_MODULE=oppia_core.settings # <- main Django settings
˓→(relative to the Django project path)
python /home/alex/data/development/django-oppia/oppia/cron.py # <- full path to
˓→the cron.py file
2.3. Installation
OppiaMobile Documentation, Release 0.10.0
• This script handles activating the virtualenv correctly and ensuring all the Django modules/apps can be accessed.
We then have my cron call this wrapper script every 2 hours.
2.4 Moodle Block Installation
There are 2 main methods for installing the OppiaMobile Export Moodle Block, depending on how you are able to
access your Moodle server. After you have installed the block, please see the instructions below for setting up the
connection to the OppiaMobile server (further below).
2.4.1 Full server admin rights on your Moodle (e.g. if you ‘own’ the server)
• This would be the preferred approach
• Clone the GitHub repository https://github.com/DigitalCampus/moodle-block_oppia_mobile_export into your
moodle/blocks/ directory
• You’ll need to rename the generated directory moodle-block_oppia_mobile_export to be just oppia_mobile_export
• Visit the admin notifications page on your Moodle server to trigger installing the block
2.4.2 Local rights for your Moodle installation (e.g. on shared hosting)
• Download the zip file of the latest release of the block at: https://github.com/DigitalCampus/moodle-block_
• Open the zip file and rename the root directory to be oppia_mobile_export (instead of moodleblock_oppia_mobile_export) - you may need to unzip and re-zip this file depending on your operating system.
• In your Moodle server under the site admin -> plugins, select ‘install plugins’
• Upload your new zip file as a new block
2.4.3 Adding the block to your course
Even once you have installed the block, you may not see it appearing in the your Moodle server. This is because we
haven’t yet added it for display. You can either add the block for individual courses or have it appear on all the courses
on your Moodle server:
• Adding to a single course: on the course homepage, turn editing on, then in the ‘Add a block’ block, select the
Oppia Export Block to add to your course.
• Adding to all courses, see the Moodle Block Settings documentation
2.4.4 Block configuration to connect to an OppiaMobile server
Once the block is installed you will need to provide some settings to connect your Moodle server to an OppiaMobile
server. These settings are used to export the quiz and feedback activity questions, and also for directly publishing
your course to OppiaMobile. A Moodle server can be set up to connect to a number of different OppiaMobile servers
(conversely and OppiaMobile server can support courses from different Moodle servers). The basic set up is to provide
a default OppiaMobile server for your Moodle server to connect to, so:
• in the oppia_mobile_export block settings, enter the url, username and api_key for your OppiaMobile server.
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
• for the url you only need to enter the base url (e.g. http://demo.oppia-mobile.org/ rather than http://demo.oppiamobile.org/api/v1/ )
• for the username, use the username you use to log into the OppiaMobile server
• for the API key, you can obtain this when you log into the OppiaMobile server and visit your profile page
This will allow any teachers/admins on your Moodle server to publish to the specified OppiaMobile server.
You may wish to add other connections (e.g. on a user by user basis, or to other OppiaMobile servers), you can do this
from the block:
• select the ‘add new server connection’ option from the oppia_export_block
• enter the url, username and API key (as described in the info above)
• when you export your course using the block, you can select which connection you’d like to use.
2.5 Installing on Amazon Web Services
To make it easier for you to get an OppiaMobile server up and running, we have created an Amazon Web Services
machine image that you can copy and comes pre-packaged with the latest version of the OppiaMobile Server so will
run ‘out of the box’.
2.5.1 Launch an AWS Machine Image
Once you have created your account on AWS:
• Go into your instances page
• Select ‘launch instance’
• Select ‘Community AMIs’
• Search for ‘oppia’ and you should see the most recent version of the OppiaMobile AMI listed
• Launch your new instance - you can alter the instance configuration (security groups etc) during the rest of the
launch instance process.
Note: When you search the OppiaMobile server AMI will only appear in the search results if you have selected the
‘EU (Ireland)’ zone
Once your instance is up and running you will be able to assign a static IP, access via your web browser and log into the
server using SSH. It is beyond the scope of this guide to give the full information about how to connect and configure
your AWS account instances.
2.5.2 Allowed Hosts
To make your AWS machine accessible, you will need to add the IP address (and/or domain name) to ALLOWED_HOSTS in /home/oppiamobile/oppia_web/oppia_web/settings.py. This is due to an update in Django 1.8.16, see: https://docs.djangoproject.com/en/1.11/releases/1.8.16/
2.5. Installing on Amazon Web Services
OppiaMobile Documentation, Release 0.10.0
2.5.3 Passwords
When you install and launch your instance it is set up with a default set of usernames/passwords:
• MySQL root password: ‘default’
• MySQL oppia user password: ‘default’ - this is the user that Django uses to connect to your database. When you
have changed this password you should also update the django settings.py file (at: /home/oppiamobile/
oppia_web/oppia_web/settings.py) to reflect the new database password.
• Django super user: username ‘admin’ and password ‘default’
Warning: You are very strongly advised to change these passwords as soon as you have set up your instance
2.5.4 Directories and location of files
All the required files are stored in the /home/oppiamobile directory, which has the following structure:
• django-oppia (dir): the OppiaMobile server application files
• env (dir): root of the virtualenv
• media (dir): the media directory for Django (this directory served directly by Apache)
• oppia-cron.sh (file): a shell script for running the OppiaMobile cron task - it’s unlikely you’ll ever need to do
anything with this file.
• oppia_web (dir): the Django project files (containing settings.py and urls.py etc)
• static (dir): the static directory for Django (this directory is served directly by Apache)
• upload (dir): stores the course uploads
Please note that on this machine the django-oppia server is installed as a clone from GitHub (rather than using the pip
install method described in the standard installation instructions).
Warning: In the main django settings, the server is set to run in debug mode. This will be fine when you are
testing, but once you are ready to start providing the server live, you should change this setting to DEBUG=False
2.5.5 Updating django-oppia server code from core
The code is based on a ‘point-in-time’ version of the OppiaMobile server code, so once you have set up your instance,
you should try to keep it up to date.
View the docs on how to upgrade
2.5.6 Creating your own version of django-oppia
If you have created your own fork of django-oppia (for example to customise the look and feel), then you can point git
to the fork of your code by editing the /home/oppiamobile/django-oppia/.git/config file and pulling
the code from your fork instead.
More information on customising OppiaMobile
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.5.7 Environment information
The current version of the instance is running:
• Ubuntu 16.04 LTS Server
• Apache 2.4
• Mysql 5.7
• Django 1.11.6
• TastyPie 0.14.0
• OppiaServer 0.10.0
2.5.8 Email configuration
By default your AWS OppiaServer instance is not configured to send email, any emails generated by the system (for
example reset password messages) are just saved as plain text files in the /tmp directory.
To enable sending email you will need to:
• configure your AWS account to enable email sending (using SES service)
• comment out or remove the EMAIL_BACKEND and EMAIL_FILE_PATH directives in the /home/
oppiamobile/oppia_web/oppia_web/settings.py file.
• update the SERVER_EMAIL directive in settings.py to use an email address that is authorised to send via
your SES.
2.6 Installing VirtualBox Image
As well as the Amazon Web Services Machine Image, we also have a VirtualBox image of a new/clean installation of
the OppiaMobile Server.
The latest version is available to download from:
The configuration is all set up with the same directory structure, passwords etc as on the AWS image, so you can find
all the details here.
The only additional information you should need is the user login account:
• username: oppia
• password: default
Obviously as soon as you have installed the machine you should change this to something much more secure.
2.6.1 Environment information
The current version of the instance is running:
• Ubuntu 16.04 LTS Desktop
• Apache 2.4
• Mysql 5.5
2.6. Installing VirtualBox Image
OppiaMobile Documentation, Release 0.10.0
• Django 1.8.14
• TastyPie 0.13.3
• OppiaServer 0.9.6
2.7 Upgrading OppiaMobile Server
To ensure you get all the latest features, bug fixes and patches, it’s important to keep your OppiaMobile server up to
The upgrade process is described below, with the paths/directories described as OppiaMobile server is set up on both
the AWS and VirtualBox machine images. If you have installed OppiaMobile server to different location, then amend
the paths/directories as required. Or, if you have your own clone of the OppiaMobile server code, you will need to
merge the core version into your clone and resolve any conflicts, before updating your server.
Your server must be connected to the internet for the upgrade process.
2.7.1 Backup
Ensure you have a backup of your OppiaMobile database, code and any uploaded files/courses
2.7.2 Pull the latest updates from the core version
1. Move to the django-oppia directory: $ cd /home/oppiamobile/django-oppia/
2. Pull the latest updates: $ sudo git pull
2.7.3 Activate the VirtualEnv
1. Move to Oppia directory: $ cd /home/oppiamobile
2. Activate virtual environment: $ source env/bin/activate
You will see the prefix (env) at the beginning of your command line. Once the upgrade is complete you can deactivate the virtual environment using (env)$ deactivate.
2.7.4 Check for any updated/new required packages
1. Check and install: (env)$ pip install -r django-oppia/requirements.txt
Any updated or new packages will now be installed
2.7.5 Migrate the database
1. Move to oppia_web directory: (env)$ cd /home/oppiamobile/oppia_web
2. Migrate database with: (env)$ python manage.py migrate
2.7.6 Copy static files
1. Copy static files with: (env)$ python manage.py collectstatic
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.7.7 Restart Apache
1. Restart Apache server: $ sudo service apache2 restart
2.8 Server Settings
These are the settings that you may want to alter to adapt to your OppiaMobile installation.
To edit these settings you will need to edit the local_settings_xxx.py file, and for them to take effect you will
need to restart your web server.
‘‘’REGISTER’:100, # given when user first registers ‘QUIZ_ATTEMPT_OWNER’:5, # given
to the quiz owner when another user attempts their quiz ‘QUIZ_FIRST_ATTEMPT’:20, # for
the first attempt at a quiz ‘QUIZ_ATTEMPT’:10, # for any subsequent attempts at a quiz
‘QUIZ_FIRST_ATTEMPT_THRESHOLD’:100, # Threshold for getting bonus points for first attempt at quiz (must be 0-100) ‘QUIZ_FIRST_ATTEMPT_BONUS’:50, # Bonus points for getting
over the threshold on first attempt at quiz ‘QUIZ_CREATED’:200, # for creating a quiz ‘ACTIVITY_COMPLETED’:10, # for completing an activity ‘MEDIA_STARTED’:20, # for starting media ‘MEDIA_PLAYING_INTERVAL’:30, # interval in seconds for which points are given ‘MEDIA_PLAYING_POINTS_PER_INTERVAL’:5, # no points per interval media is playing ‘MEDIA_MAX_POINTS’:200, # the maximum number of points available for any single media play
The defines the metadata info that is sent back from the app.
Default: True
This settings determines whether users are able to self register (i.e. anyone can create an account) on the server. Set
this to False to prevent just anyone registering on your server - you will need to create their accounts yourself instead
using the standard Django user management.
Default: True
Determines if a users gravatar will appear next to their name (in the leaderboard/activity reports etc)
2.8. Server Settings
OppiaMobile Documentation, Release 0.10.0
Default: True
This setting determines whether only users with the Django is_staff status are allowed to upload new courses. When
this setting is True, only users with the is_staff status are able to upload courses. If this setting is set to False, any
registered user on the server is able to upload courses.
You can also give upload permissions to individual users (whatever their staff status) by setting the can_upload option
to true in their user profile.
Default: True
This setting determines whether the points system is enabled for this server. It currently just hides the points from
display on the mobile app.
Default: False
Determines if users with the is_staff permission will earn points or not.
This setting is ignored if
Default: False
Determines if the user who uploaded the course will earn points or not for activity within this course. This setting is
ignored if OPPIA_POINTS_ENABLED is False.
Default: False
Determines if teachers on the course will earn points or not for activity within this course. This setting is ignored if
Default: True
This setting determines whether the badges system is enabled for this server. It currently just hides the badges from
display on the mobile app.
Defines the method that is used for awarding a badge. This may be set to one of:
• BADGE_AWARD_METHOD_ALL_ACTIVITIES (default) - all activities in the course must be completed,
and all quizzes passed
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
• BADGE_AWARD_METHOD_FINAL_QUIZ - only need to pass the final quiz
• BADGE_AWARD_METHOD_ALL_QUIZZES - all the quizzes in the course must be passed
Default: True
Whether or not to turn on Google Analytics tracking for your Oppia server.
Your Google Analytics tracking code - only used if OPPIA_GOOGLE_ANALYTICS_CODE is set to True.
Your Google Analytics domain name - only used if OPPIA_GOOGLE_ANALYTICS_CODE is set to True.
Default: 5242880 (5Mb)
This is the maximum file course file size that can be uploaded (in bytes). This is to prevent users uploading very large
files - for example if they haven’t appropriately resized images, or included video or other media files. Large course
upload files may cause issues for end users (particularly those with slow internet connections) when trying to install
the course on their phone.
If you define a MAX_UPLOAD_SIZE property in the SettingProperties table (under the Django admin), that value will
take precedence from the one defined in the _settings.py file
List of the video file MIME types that will be accepted for upload to the server.
List of the audio file MIME types that will be accepted for upload to the server.
Default: 2017011400
The minimum version no of the Moodle - Oppia export block to process the quizzes locally on the server.
Default: 0
Defines how many results will be returned per page in the API. When set to 0, all results will be returned.
2.8. Server Settings
OppiaMobile Documentation, Release 0.10.0
Default: True
Defines if the Google Device Admin functionality is enabled. Note that if it is enabled here and in the Oppia app, then
extra information is required in the app to ensure users are aware of these permissions. If this info is not provided in
the app, then it may get removed from Google Play.
2.9 OppiaMobile Server Management Commands
Django’s manage.py runs a variety of Django admin tasks, and each project can add their own. OppiaMobile bundles
some management commands to perform some tasks that make more sense to be executed from the command line
than include them in the admin user interface of the web page.
To run any of this commands, just use the manage.py script like with the common Django admin actions (i.e.
activating the virtualenv and setting your path to the server folder.
To view all the commands available in any Django project, you can type manage.py help to view a list
of them, grouped by Django app. Also, you can access the help for a command typing manage.py help
2.9.1 Available commands
cleanup_quizzes: Cleans up old data (quizzes and questions) that is not relevant anymore. It removes all the
quizzes and its related data (properties, questions, correct answers, etc) that are not part of a course anymore and don’t
have any attempt. Before actually deleting the data, the command prompts the user for confirmation.
cleanup_uploads: Cleans up any old files in the oppia uploads directory. Cleans the temporary zip files
uploaded to the server that are no longer needed. It also checks that every course in the server has its related course
package so it can be downloaded, printing a warning for each of them that doesn’t satisfy this.
update_short_answer_scores: Updates the scores for short answer questions. It receives an additional
parameter pointing to a CSV file that includes the response attempts to update and its new scores. It then goes to the
related quiz attempts and updates their total scores and checks the pass threshold with the new score.
update_summaries: Updates course and points summary tables. A shortcut to execute the cron task to update
course activity and points summary tables.
2.10 Utilities
All utility scripts can be found in the django-oppia/oppia/utils directory.
2.10.1 cartodb_update.py
This script updates the user location map in CartoDB
Usage: cartodb_update.py <CartoDB Account Name> <CartoDB API Key>
More information about how to set up and configure the location map
Note: For this script to run successfully, you will need to have the your virtualenv activiated (if applicable) and
environment variables set to point to your Django settings file - similar to how you set up the OppiaMobile cron task
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.10.2 ip2location.py
This script converts the IP addresses from the Tracker log to a latitude/ longitude location, for displaying on the
CartoDB user map visualization.
Usage: ip2location.py <IP Address Labs API Key> <Geonames username>
More information about how to set up and configure the location map
Note: For this script to run successfully, you will need to have the your virtualenv activiated (if applicable) and
environment variables set to point to your Django settings file - similar to how you set up the OppiaMobile cron task
2.10.3 media_scan.py
This will scan a given directory of video files and create a collection of image screenshots from throughout the video,
along with a file containing all the code (md5 digest, video length, filesize etc) that you can cut and paste into your
Moodle page.
You will need to have ffprobe installed to be able to run this script. This can be downloaded from: http://ffmpeg.
Usage: python media-scan.py /home/input/video/dir/ /home/output/dir/
The first parameter is the input directory (where all your videos are stored).
The second parameter is the directory to output all the images and video tags code.
The following optional parameters are also available:
• -f This determines the number of images that will be created for each video (they will be evenly divided between
the length of the video). Example usage:
python media-scan.py /home/input/video/dir/ /home/output/dir/ -f 10
This will create 10 video screenshot images for each video in the input directory.
The default is 5 images per video
• -w This determines the width in pixels of the output images. Example usage:
python media-scan.py /home/input/video/dir/ /home/output/dir/ -w 500
With this all the images will be 500 pixels wide
The default is 250.
2.10.4 media_url_check.py
This script checks the urls of all the media activities in uploaded courses. This helps to prevent your users getting file
not found errors when downloading the videos included in your courses.
Usage: python media_url_check.py
Note: For this script to run successfully, you will need to have the your virtualenv activiated (if applicable) and
environment variables set to point to your Django settings file - similar to how you set up the OppiaMobile cron task
2.10. Utilities
OppiaMobile Documentation, Release 0.10.0
2.10.5 oppia-schema.xsd
This is the XML Schema Definition for the course XML file, it is used by the OppiaMobile server to check that any
courses uploaded are valid OppiaMobile course packages.
2.10.6 tidy_upload_dir.py
This script checks the upload course directory (as defined in the Django settings.py file) for any course packages that
are now obsolete.
Usage: tidy_upload_dir.py
Note: For this script to run successfully, you will need to have the your virtualenv activiated (if applicable) and
environment variables set to point to your Django settings file - similar to how you set up the OppiaMobile cron task
2.11 Branches and Release Process
The page describes how the core Oppia repositories are structured for developing and managing new features and
fixes. The following process is applied to all 3 of the Oppia GitHub repositories (server, Android app and Moodle
2.11.1 Branches/Issues/Code Management
1. A new dev release branch is created (e.g. ‘v1.2.3’) - this is the branch to which all fixes and issues will be
merged into for testing, before being merged into the master branch.
2. A new branch is created for each issue to be fixed in the development cycle (e.g. ‘issue-567’)
3. Code is developed on the issue branch
A couple of exceptions to the above process:
1. documentation (in the server repository) will be added directly into the master branch
2. very minor fixes (that don’t warrant their own issue branch) may be applied directly to the release branch
3. database updates/re-structuring will be applied directly on the release branch. This saves conflicts if their are
database updates on multiple issue branches
2.11.2 Release Process
1. Once coding and testing of the feature is completed, the issue branch will be merged into the release branch
2. Once all the features for the release have all been merged into the release branch, integration testing then takes
place, to ensure there are no conflicts.
3. The release branch is then merged into the master branch and the master branch is tagged with the release
4. Documentation then reviewed for any changes
5. Clean up old branches from Github
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.12 Testing OppiaMobile
2.12.1 Testing Process for OppiaMobile App
OppiaMobile incorporates several types of tests to make the app stronger.
These types of tests are Local Unit Tests, Instrumented Tests and User Interface Tests.
Local Unit Tests
The Local Unit Tests are tests that run on a local JVM, therefore we do not need a physical device or emulator to run
this type of tests, which make the execution time to be shorter.
The main path for these tests is src/test/java. It is mandatory for this type of tests to include the JUnit 4
framework dependency to the app build.gradle file.
testCompile 'junit:junit:4.12'
The tests methods that we create must have the tag @Test right before the method declaration, and must end with an
assertion to check whether the test passes or not. For example:
public void Storage_correctDownloadPath(){
Optionally, the tests could provide a preconditions and post conditions blocks
//Preconditions block
public void setUp() throws Exception{...}
//Preconditions block
public void setUp() throws Exception{...}
Instrumented Unit Tests
The Instrumented Unit Tests are test that run on a physical device or emulator. This type of tests is convenient when
we need access to instrumentation information (App context for example).
The main path for this tests is src/androidTests/java.
To create and run this test, first we need to install the Android Support Repository from the Android SDK Manager.
After that, we need to add some dependencies to the app build.gradle file:
androidTestCompile 'com.android.support:support-annotations:24.0.0'
androidTestCompile 'com.android.support.test:runner:0.5'
androidTestCompile 'com.android.support.test:rules:0.5'
In addition, we need to add the default test instrumentation runner to use JUnit 4 test classes:
2.12. Testing OppiaMobile
OppiaMobile Documentation, Release 0.10.0
android {
defaultConfig {
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
When we create a test class, there are some things we have to pay attention.
• We need to add the @RunWith(AndroidJUnit4.class) tag before the test class definition.
• We also need to add the @Test tag to all our test methods (as we did in the Local Unit Tests section)
• The setUp() and tearDown() methods have the same structure as in the Local Unit Tests section.
• All our tests methods should include the throws Exception line in the method definition.
• The assertion part is the same as in the Local Unit Tests section.
User Interface Tests
The User Interface Tests are useful to verify that the UI components of the app works correctly and do not provide a
poor experience to the final user.
OppiaMobile make use of these tests using the Espresso testing framework, that we might consider it as an
Instrumentation-based framework to test UI components.
With Instrumentation-based we mean that it works with the AndroidJUnitRunner test runner (as mention in the
previous section).
To use the Espresso library, we need to make sure to follow the same steps described in the previous section (Instrumented Unit Tests) and also we need to add the following dependency to the app build.gradle file:
androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.1'
Note: It is recommended to turn off the animations on your test device (Settings –> Developing Options), as they
might cause unexpected results or may lead your test to fail.
There are some things we need to take into account:
• We need to specify at the beginning of the class the activity that will be tested. This is done with the @Rule tag
and with a ActivityTestRule object:
public ActivityTestRule<OppiaMobileActivity> oppiaMobileActivityTestRule =
• The Espresso nomenclature is based on three aspects. First we need to find the view we want to test. Next, we
have to perform an action over that view. And finally, we need to inspect the result. This is done as follows:
//Find the view
//Perform an action
//Find the view
//Inspect the result
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
Mock Web Server
OppiaMobile made use of the MockWebServer by okhttp (https://github.com/square/okhttp/tree/master/
The mock web server is useful to enqueue some responses and in this way testing the client side.
First, we need to add the MockWebServer dependency to our app build.gradle file:
testCompile 'com.squareup.okhttp3:mockwebserver(insert latest version)’
After that, we are able to create MockWebServer objects. For example:
MockWebServer mockServer = new MockWebServer();
String filename = “responses/response_201_login.json”; //Premade response
mockServer.enqueue(new MockResponse()
On the other hand, we need to configure our app to communicate correctly with this mock web server. To achieve that,
OppiaMobile uses the class MockApiEndpoint, whose method getFullURL() will give us the correct path on
which the mock web server is listening.
Temporary Files and Folders
Junit4 allows us to create temporary files and folders with the guarantee that it will delete all of them when the test
finishes, whether the test passes or fails.
The TemporaryFolder object must be created using the @Rule tag.
public TemporaryFolder folder = new TemporaryFolder();
File tempFolder = folder.newFolder(“tempFolder”);
File tempFile = folder.newFile(“tempFile.txt”);
Running Tests
We have several ways to run tests:
• Run a single test:
First, open the class where the test is located, and then right-click the test and click Run.
• Run all tests in a class:
Right-click the class you want to test and click Run.
• Run all tests classes in a directory:
Right-click the directory you want to test and click Run tests.
• Run tests using a test suite:
2.12. Testing OppiaMobile
OppiaMobile Documentation, Release 0.10.0
A test suite allows us to run a collection of test that we want.
To create a test suite, we need to create a new class and add these tags to the beginning of it:
@Suite.SuiteClasses({WelcomeUITest.class, LoginUITest.class, RegisterUITest.
˓→class, ResetUITest.class})
public class UITestSuite {...}
If we run this suite, the tests inside in the classes listed in @Suite.SuiteClasses() will be executed.
2.12.2 Testing Process for OppiaMobile Server
The Oppia server uses Django’s inbuilt unit testing framework .
All the unit tests can be found under: https://github.com/DigitalCampus/django-oppia/tree/master/oppia/tests
Run the tests on your Oppia server
1. Activate the virtual environment (eg: /home/www/oppia/$ source env/bin/activate)
2. Run all the tests with python manage.py test oppia.tests
Adding more tests
If you are adding additional functionality to the Oppia server, you can add tests for this functionality using the standard
Django unit testing framework.
2.12.3 Testing Quiz Content
2.13 Remote Device Admin
2.13.1 Introduction
This feature allows the administrator of an OppiaMobile instance to remotely manage some options of the devices
which have the app installed. For example, it can be useful to manage the device losts, locking them or remotely
wiping all the phone data, specially important in the case of health workers who may have data/photos stored on the
In the mobile part, it uses the Android Device Administration API to access some device features at system level. The
available features in this API include the possibility to manage security options of the device (screen lock system, user
password, enforce password complexity), as well as enabling/disabling the device cameras or perfoming a data wipe,
restoring the device to its factory defaults.
Currently, OppiaMobile supports the following options:
• Enable/disable device cameras
• Lock device and set a new password
Due to its severity, the Device Administration permissions cannot be automatically granted to an app, so they must be
confirmed by the user. To activate the Romete Device Admin, there is an option available in the Settings activity:
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.13. Remote Device Admin
OppiaMobile Documentation, Release 0.10.0
Once the option is checked, a dialog appears prompting the user for the admin permissions, where he can see before
activating the functionality which admin operations will the app be allowed to perform:
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.13. Remote Device Admin
OppiaMobile Documentation, Release 0.10.0
Once we have permissions, we can see OppiaMobile as an administrator app in the Settings–>Security section of the
phone, where we can disable its features again (the app will noticed it and update its configuration). The remote device
admin can be also disabled from the Settings activity of the app.
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.13. Remote Device Admin
OppiaMobile Documentation, Release 0.10.0
Below you can see an image of how the camera app looks when you have disabled the device cameras from the remote
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.13. Remote Device Admin
OppiaMobile Documentation, Release 0.10.0
2.13.2 Architecture
The communication needed by the system is not the usual where the client is the one that initiates the request, but the
opposite, as is the server the one who has to start the request for a given transaction. This is implemented with a push
messaging mechanism.
This functionality is implemented using the Google Cloud Messaging platform, a free service by Google to send
push messages to client apps through their GCM connection servers. The service handles all aspects of enqueuing of
messages and delivery to the target application running on the target device. The implementation includes the GCM
Google connection server, the OppiaMobile server that interacts with the connection server via HTTP protocol, and
the Android client app that receives the messages.
1. First of all, to receive and send GCM messages the app must register with GCM and get a unique identifier
called a registration token.
2. When a user registers in the app and enables the Remote admin functionality, we register the device (if it was
not previously registered) in the Google Cloud Messaging server. Also, the device sends a message to the
OppiaMobile server reporting that it has succesfully registered in the GCM servers, including in the request the
senderID that identifies it.
3. Then, when we want to perform an action in a device from the server, we send a message to the GCM connection
servers that includes the unique identifier of that device. The GCM connection server enqueues and stores the
message if the device is offline, so it doesn’t have to be online at that exact moment.
4. Once the device gets internet access, the GCM server sends the message to it, that receives it and proccesses the
order accordingly.
2.13.3 Setting up (customization)
Compiling the app
Since the app uses the latest version of the Google Cloud Messaging library, we could face some problems when trying
to compile the project. For the mobile version, we need to check that we have the following libraries installed:
• We need the Google Services library installed (via SDK Manager), at least the 1.4.0 version
• We need to include in the project the library com.google.android.gms:play-services-gcm, at
least the 8.1.0 version.
• Android buildTools v21.1.2 or superior
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
In some cases, we can face a DexLoader error when building the project once we have solved all the dependencies.
Android APKs contain executable bytecode files in the form of Dalvik Executable (DEX) files, which contain the
compiled code used to run the app. The Dalvik Executable specification limits the total number of methods that can be
referenced within a single DEX file to 65,536, including Android framework methods, library methods, and methods
the app own code. The problem is probably related with the addition of the Google Play Services library, as it contains
a huge amount of methods. To solve it, add only the GCM part of the Google Services SDK instead of the whole
library, as it causes limit overhead in the Dalvik compile process.
Registering the app in GCM
To use a custom OppiaMobile server, each project needs its own Google Cloud Messaging keys, both for the server
and client (app) side.
To obtain an API key for the Google Cloud Messaging platform, you just need to create it from this link in the
Google developers console: https://developers.google.com/mobile/add?platform=android&cntapi=gcm . You need
to be logged in with a Google account, and just introduce the values in the form. For the app name, you can set
whatever you want, and in the package, you must set the android package name (in the case of OppiaMobile, it is
In the next screen, select the Cloud Messaging option if it doesn’t start selected, and press the “Choose and configure
2.13. Remote Device Admin
OppiaMobile Documentation, Release 0.10.0
services” button.
Once you do that, you’ll see your API keys for the project. The first one, the “Server API Key”, is the one that goes in
the server side.
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
After this, you can go to the next step and download the google-services.json file with all the configuration values.
2.13. Remote Device Admin
OppiaMobile Documentation, Release 0.10.0
Setting up within the app
For the app, there are two possible options: - If the project is configured with Android Studio and gradle, simply put
the google-services.json at the app directory level. The plugin com.google.gms.google-services
will take the values from the JSON and generate the needed resource values. - If the project is configured to be built
with the Eclipse ADT plugin, that resource has to be added manually. To do so, we need to add (or update the one
present) the gcm_defaultSentderId string value (in res/values/strings.xml) with the one in the JSON
Setting up the server side for managing
For the server side, the process is very straight forward: it is done in the settings file for each state (local, staging, live)
configuring the following properties:
• update the DEVICE_ADMIN_ENABLED property to True
• set the GCM_APIKEY property with the “Server API Key” generated in the Google Cloud Messaging platform.
2.14 Launching OppiaMobile Activities from other Applications
Note: This development is a work in progress, so not everything may be completed and tested well. We’d welcome
any feedback and suggestions on how we can improve on what has already been done.
In order to allow other applications to launch specific activities in the OppiaMobile app, this can now be done by using
a standard weblink.
The main use-cases for this functionality are:
• data collection or other support tools needing to link directly to refresher information/activities
• being able to send via SMS, WhatsApp or similar a direct link to a specific activity
Using a link, rather than an Android intent, helps to direct the user to the activity online if the app is not installed.
The links used should be in the following format:
The digest is a unique identifier for the specific activity in OppiaMobile - these can be found in the module.xml of the
course zip package.
Here is an example of a link appearing in a text message (of course this link could also be in other apps):
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.14. Launching OppiaMobile Activities from other Applications
OppiaMobile Documentation, Release 0.10.0
As the app is registered to open these kinds of links, when you clink on a URL like that, Android will prompt you
for which app to open the link with. If you select the OppiaMobile app, it shows you a page informing you of the
functionality, and allows you to continue to that concrete activity:
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.14. Launching OppiaMobile Activities from other Applications
OppiaMobile Documentation, Release 0.10.0
From here, you can either open the activity or close this window. The tick in the bottom right indicates if the current
logged in user has already completed this activity. If the user is not logged in right now, it will also show the info of
the activity, but won’t let you navigate to it:
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.14. Launching OppiaMobile Activities from other Applications
OppiaMobile Documentation, Release 0.10.0
If the course that contains the activity is not installed in the device, the app won’t find the activity by its digest, and it
will show the message:
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
2.14. Launching OppiaMobile Activities from other Applications
OppiaMobile Documentation, Release 0.10.0
This is the main functionality developed so far, but we still have yet to develop the part when the user selects the
browser as the app with which to open the link (or the OppiaMobile app is not installed) - and will then redirect to the
activity on the web.
2.15 Change Log for OppiaMobile Platform Components
The OppiaMobile platform consists of 3 core components (server, client app and the Moodle export block). This page
summarises the currently released versions of each of these and the changelog history for each.
2.15.1 OppiaMobile Server (Django)
OppiaMobile Server Change Log
To see the upcoming feature developments and bug fixes, please refer to the monthly milestones on GitHub
v0.10.1 - not yet released
v0.10.0 - Released 1 Feb 2018
Warning: This release requires Django 1.11 LTS. Previous versions were targeted for Django 1.8 LTS, so an
upgrade of your Django will be required when updating to this version of the OppiaMobile server.
• 421: Move to django v1.11.6 - https://github.com/DigitalCampus/django-oppia/issues/421
• 415: add defusedxml==0.5.0 as requirement - https://github.com/DigitalCampus/django-oppia/issues/415
• 400: Add docs for updating the theme on the app for custom versions - https://github.com/DigitalCampus/
• 399: Check documentation for creating own version of app - https://github.com/DigitalCampus/django-oppia/
• 377: Course activity on summary overview showing dates into far future - https://github.com/DigitalCampus/
• 390: Document management commands (purpose & how to run etc) - https://github.com/DigitalCampus/
• 431: Update to use TastyPie v0.14.0 - https://github.com/DigitalCampus/django-oppia/issues/431
• 433: Device admin setting error - https://github.com/DigitalCampus/django-oppia/issues/433
• 440: Option for user to export data - https://github.com/DigitalCampus/django-oppia/issues/440
• 439: Option for user to delete their account/data completely - https://github.com/DigitalCampus/django-oppia/
• 358: Improve layout of ‘unauthorised’ page - https://github.com/DigitalCampus/django-oppia/issues/358
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
Previous Versions
OppiaMobile Server Change Log for v0.9.x
To see the upcoming feature developments and bug fixes, please refer to the monthly milestones on GitHub
v0.9.12 - Released 22 Jan 2018
• 411: Add new logo - https://github.com/DigitalCampus/django-oppia/issues/411
• 422: Check user course summaries - https://github.com/DigitalCampus/django-oppia/issues/422
• 415: add defusedxml==0.5.0 as requirement - https://github.com/DigitalCampus/django-oppia/issues/415
• 412: Update docs to reflect new question type functionality - https://github.com/DigitalCampus/django-oppia/
• 410: Update docs for creating a new version/Implementation of Oppia app - https://github.com/DigitalCampus/
• 425: Review and update the upgrade docs - https://github.com/DigitalCampus/django-oppia/issues/425
• 437: Redirect “link to open activity in app” to the preview page - https://github.com/DigitalCampus/
v0.9.11 - Released 29 Sept 2017
• 368: Move settings model to top level - https://github.com/DigitalCampus/django-oppia/issues/368
• 406: Update to using django 1.8.17 (more recent version of 1.8 LTS) - https://github.com/DigitalCampus/
• Hotfix to solve problem when there is more than one quiz with the same digest - https://github.com/
v0.9.10 - Released 22 Jun 2017
• 416: temp upload directory not getting deleted correctly - https://github.com/DigitalCampus/django-oppia/
• Replace and scrape thoroughly HTML entities in the course XML
v0.9.9 - Released 7 Apr 2017
• hotfix: multiple quizzes returned - https://github.com/DigitalCampus/django-oppia/pull/408 and https://github.
v0.9.8 - Released 5 Jan 2017
• 349: Management command for cleaning up old data - http://github.com/DigitalCampus/django-oppia/issues/
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
• 219: Add better error messaging/reporting when upload fails - http://github.com/DigitalCampus/django-oppia/
• 22: Add unit tests for BadgesResource - http://github.com/DigitalCampus/django-oppia/issues/issue/22
• 25: Add unit tests for CourseResource - http://github.com/DigitalCampus/django-oppia/issues/issue/25
• 26: Add unit tests for PointsResource - http://github.com/DigitalCampus/django-oppia/issues/issue/26
• 47: Add unit test for checking registration done through web form - http://github.com/DigitalCampus/
• 359: Add unit tests for permissions - http://github.com/DigitalCampus/django-oppia/issues/issue/359
• 227: Check that the direct course upload via Moodle will reject any files larger than specified for the server http://github.com/DigitalCampus/django-oppia/issues/issue/227
• 310: Change quiz export method - https://github.com/DigitalCampus/django-oppia/issues/310
• 394: Management command to clean uploads dir - https://github.com/DigitalCampus/django-oppia/issues/394
v0.9.7 - Released 20 Sept 2016
• 370: New points summary is ignoring non-course points - http://github.com/DigitalCampus/django-oppia/
• 365: Docs add info about permissions for publishing courses and app - http://github.com/DigitalCampus/
• 367: API course list - show user who published course - http://github.com/DigitalCampus/django-oppia/issues/
• 310: Change quiz export method - http://github.com/DigitalCampus/django-oppia/issues/issue/310
• 262: On course upload indicate if the digests have changed - http://github.com/DigitalCampus/django-oppia/
v0.9.6 - Released 26 Jul 2016
• 177: Add previous/next options for courses - now getting to be long list - http://github.com/DigitalCampus/
• 306: Display course progress graphically - http://github.com/DigitalCampus/django-oppia/issues/issue/306
• 327: On courses list page add option to filter by draft and archived courses - http://github.com/DigitalCampus/
• 337: On courses list page add option to edit the course - http://github.com/DigitalCampus/django-oppia/issues/
• 371: Some users having very inflated number of points - http://github.com/DigitalCampus/django-oppia/issues/
• 372: Add new summary tables to django admin pages - http://github.com/DigitalCampus/django-oppia/issues/
• 373: Summary cron - oppia.models.DoesNotExist: Tracker matching query does not exist - http://github.com/
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
v0.9.5 - Released 8 Jul 2016
Note: This release implements significant performance improvements on the server dashboard and has been achieved
by caching a lot of the data needed to generate the activity graphs and progress. After updating to this version, you
will need to check that a regular cron task is set up to run the oppia/summary/cron.py script. It may take some time (10
mins+) to run the first time if you have a lot of existing data, but after that each time the cron task is run should take
only a few seconds. If the cron task is not set up to run, then you will not see any activity in the dashboard graphs.
• 304: Deprecation warning for Django 1.8 - http://github.com/DigitalCampus/django-oppia/issues/issue/304
• 269: Add display of media/videos to the course and user views - http://github.com/DigitalCampus/django-oppia/
• 331: Cron task gives error if uploads/temp dir doesn’t exist - http://github.com/DigitalCampus/django-oppia/
• 323: Performance issues when loading dashboard with a lot of data - http://github.com/DigitalCampus/
• 243: Dashboard homepage and course pages very slow - http://github.com/DigitalCampus/django-oppia/issues/
v0.9.4 - Released 2 May 2016
• 289: Add default report for no badges (course completion rates) - http://github.com/DigitalCampus/
• 273: Refactor UserProfile model - http://github.com/DigitalCampus/django-oppia/issues/issue/273
• 314: After logout, then logging in again the page redirects to logout again - http://github.com/DigitalCampus/
• 276: Add content development training course to docs - http://github.com/DigitalCampus/django-oppia/issues/
• 313: Add architecture/workflow to docs - http://github.com/DigitalCampus/django-oppia/issues/issue/313
• 305: Refactor usage of staticfiles - using django 1.8 method - http://github.com/DigitalCampus/django-oppia/
• 339: Quiz matching query does not exist - http://github.com/DigitalCampus/django-oppia/issues/issue/339
• 303: Add option to reorder the columns in the tables - http://github.com/DigitalCampus/django-oppia/issues/
• 284: Facility to export list of users for loading into the app - http://github.com/DigitalCampus/django-oppia/
• 207: Fix issue where activities may not have descriptions entered - http://github.com/DigitalCampus/
• 280: Improved error checking for video embed helper - http://github.com/DigitalCampus/django-oppia/issues/
• 286: Implement the server side part of device admin API into the core - http://github.com/DigitalCampus/
• 284: Facility to export list of users for loading into the app - http://github.com/DigitalCampus/django-oppia/
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
• 300: Improve interface for managing cohorts - http://github.com/DigitalCampus/django-oppia/issues/issue/300
• 302: Add option to search for users to get their activity - http://github.com/DigitalCampus/django-oppia/issues/
Note: Make sure that django.contrib.staticfiles is included in your INSTALLED_APPS setting (for issue #305 above)
v0.9.3 - Released 22 Feb 2016
• 287: Separate out the local_settings for dev, staging and live - http://github.com/DigitalCampus/django-oppia/
• 290: Add local settings option for the course badges criteria - http://github.com/DigitalCampus/django-oppia/
• 270: Add documentation about the Device Admin API - http://github.com/DigitalCampus/django-oppia/issues/
• 283: Error in video embed helper (list index out of range) - http://github.com/DigitalCampus/django-oppia/
• 294: Add logging of dashboard access - http://github.com/DigitalCampus/django-oppia/issues/issue/294
• 298: Allow searching for courses in Django Admin - http://github.com/DigitalCampus/django-oppia/issues/
• 299: ‘Add cohort’ button styling - http://github.com/DigitalCampus/django-oppia/issues/issue/299
• 288: Allow downloading of raw data from the summary overview page - http://github.com/DigitalCampus/
• 274: Fix issue with date picker not displaying the date - http://github.com/DigitalCampus/django-oppia/issues/
• HOTFIX (1 Mar 2016): 316: One user has 124 badges - http://github.com/DigitalCampus/django-oppia/issues/
v0.9.2 - Released 10 Dec 2015
• 271: Add documentation for the training plans - http://github.com/DigitalCampus/django-oppia/issues/issue/
• 277: Add page in the server to allow easier generation of video embed code - http://github.com/DigitalCampus/
v0.9.1 - Released 23 Oct 2015
• 265: Write docs on points and badging - http://github.com/DigitalCampus/django-oppia/issues/issue/265
• 267: Updating for Django 1.8 - http://github.com/DigitalCampus/django-oppia/issues/issue/267
• 266: Update home page (not logged in) and about page - http://github.com/DigitalCampus/django-oppia/issues/
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
v0.9.0 - Released 11 Oct 2015
• 250: Add docs about groups and permissions - https://github.com/DigitalCampus/django-oppia/issues/issue/250
• 255: Don’t show upload option in main menu if no permissions - https://github.com/DigitalCampus/
• 254: Update and redesign the user activity page on the dashboard - https://github.com/DigitalCampus/
• 260: RelatedObjectDoesNotExist error if user has no profile record - https://github.com/DigitalCampus/
• 261: Add link to django admin in menu (for superusers) - https://github.com/DigitalCampus/django-oppia/
• 264: Allow editing of profiles by staff users - https://github.com/DigitalCampus/django-oppia/issues/issue/264
• 239: Check why getting a lot of duplicate tracker items in the table - https://github.com/DigitalCampus/
• 208: On user page show graph of activity - https://github.com/DigitalCampus/django-oppia/issues/issue/208
• 253: Review permissions on dashboard to make sure they’re sensible - https://github.com/DigitalCampus/
OppiaMobile Server Change Log for v0.8.x
v0.8.0 - released 15 Sept 2015
• 237: Update tests and test data now that cohorts have been restructured - https://github.com/DigitalCampus/
• 244: How to suppress the UnreadablePostError emails - https://github.com/DigitalCampus/django-oppia/issues/
• 238: In Cohorts allow showing full leaderboard - https://github.com/DigitalCampus/django-oppia/issues/issue/
• 245: Add option to retreive the course progress only - https://github.com/DigitalCampus/django-oppia/issues/
• 252: Cohorts - UI to add courses to a cohort - https://github.com/DigitalCampus/django-oppia/issues/issue/252
• 251: Date/time field on cohort form - use datepicker - https://github.com/DigitalCampus/django-oppia/issues/
• 248: Add option to download the course file directly from the course listing page - https://github.com/
• 249: Add option to bulk upload students - https://github.com/DigitalCampus/django-oppia/issues/issue/249
• 222: Add better titles for pages - https://github.com/DigitalCampus/django-oppia/issues/issue/222
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
OppiaMobile Server Change Log for v0.7.x
v0.7.5 - released 3 Jun 2015
• 241: Quizzes on course page are just showing ‘quiz’ as title - https://github.com/DigitalCampus/django-oppia/
• 242: Show better activity titles in points table - https://github.com/DigitalCampus/django-oppia/issues/issue/242
v0.7.4 - released 31 May 2015
• 232: Check that users, quizzes, courses etc can be deleted without removing the points etc - https://github.com/
• 231: Increase course shortname length - https://github.com/DigitalCampus/django-oppia/issues/issue/231
• 235: Update google graphs to cope with larger numbers on y axis - https://github.com/DigitalCampus/
• 226: Deprecation warning for Django 1.8 - https://github.com/DigitalCampus/django-oppia/issues/issue/226
• 236: Add information on providing multilingual content - https://github.com/DigitalCampus/django-oppia/
v0.7.3 - released 15 May 2015
• https://github.com/DigitalCampus/django-oppia/issues/issue/224 - view for cohort activity
• 230: Prevent staff users getting points even for quiz attempts - https://github.com/DigitalCampus/django-oppia/
v0.7.2 - released 29 Mar 2015
• https://github.com/DigitalCampus/django-oppia/issues/issue/220 - update course list display
• https://github.com/DigitalCampus/django-oppia/issues/issue/193 - move to Django 1.7
• https://github.com/DigitalCampus/django-oppia/issues/issue/223 - Cohort can now be linked to multiple courses
v0.7.1 - released 18 Feb 2015
• https://github.com/DigitalCampus/django-oppia/issues/issue/170 - publishing directly via API
v0.7.0 - released 11 Feb 2015
• https://github.com/DigitalCampus/django-oppia/issues/issue/213 - reset password using email address
• https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/issues/issue/117 - add support for Moodle url activities
• https://github.com/DigitalCampus/django-oppia/issues/issue/141 - remove course download model
• https://github.com/DigitalCampus/django-oppia/issues/issue/129 - visualisation menu update
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
• https://github.com/DigitalCampus/django-oppia/issues/issue/215 - add course manager model
OppiaMobile Server Change Log for v0.6.x
v0.6.0 - released 22 Dec 2014
• https://github.com/DigitalCampus/django-oppia/issues/211 - save phone no on register via API
• https://github.com/DigitalCampus/django-oppia/issues/212 - Fix quiz titles
OppiaMobile Server Change Log for v0.5.x
v0.5.3 - released: 20 Dec 2014
• Fix https://github.com/DigitalCampus/django-oppia/issues/206 - Don’t show lat/lng of 0/0
• Fix https://github.com/DigitalCampus/django-oppia/issues/142 - update efficiency of updating cartodb
• Fix https://github.com/DigitalCampus/django-oppia/issues/87 - change upload course process
• Fix https://github.com/DigitalCampus/django-oppia/issues/194 - script to set up environment
• Fix https://github.com/DigitalCampus/django-oppia/issues/210 - return point by course
v0.5.2 - released: 26 Oct 2014
• Start https://github.com/DigitalCampus/django-oppia/issues/112 - Show preview of courses via mobile web enabled pages
• Fix https://github.com/DigitalCampus/django-oppia/issues/190 - Store extra activity data on upload
• Fix https://github.com/DigitalCampus/django-oppia/issues/192 - Course.owner invalid attibute
• Fix https://github.com/DigitalCampus/django-oppia/issues/195 - show activity for particular user
• Fix https://github.com/DigitalCampus/django-oppia/issues/148 - Use alternative (free) service for IP to location
v0.5.1 - released: 30 Sept 2014
• Enable multi-lang feeback and quiz activities
Change Log for v0.4.x
v0.4.4 - released: 18-Aug-2014
• Fix https://github.com/DigitalCampus/django-oppia/issues/179 - Filter courses by tag
• Fix https://github.com/DigitalCampus/django-oppia/issues/178 - Visualisations to cover last year only
• Fix https://github.com/DigitalCampus/django-oppia/issues/180 - Visualisations - allow selection of start date
• Fix https://github.com/DigitalCampus/django-oppia/issues/96 - Course activity - allow selection of start/end
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
• Fix https://github.com/DigitalCampus/django-oppia/issues/147 - Update docs for Virtual Machine
• Fix https://github.com/DigitalCampus/django-oppia/issues/183 - Graph loading image
• Fix https://github.com/DigitalCampus/django-oppia/issues/182 - Allow selection of date range and interval on
v0.4.3 - released: 18-Jul-2014
• Fix https://github.com/DigitalCampus/django-oppia/issues/175 - Error in signals.py
v0.4.2 - released: 2-Jul-2014
• Fix https://github.com/DigitalCampus/django-oppia/issues/174 - Error in course API call
v0.4.1 - released: 27-May-2014
• Fix https://github.com/DigitalCampus/django-oppia/issues/150 - add optional job title and organisation to profile
• Reset password facility https://github.com/DigitalCampus/django-oppia/issues/168
• Fix https://github.com/DigitalCampus/django-oppia/issues/173
• Fix https://github.com/DigitalCampus/django-oppia/issues/171
v0.4.0 - released: 1-Apr-2014
• Moved to using BootStrap for design
• https://github.com/DigitalCampus/django-oppia/issues/119 - using gravatars now optional
Change Log for v0.3.x
v0.3.0 - released: 30 Mar 2014
• Moved to beta development status
• Updated oppia-schema.xsd
• https://github.com/DigitalCampus/django-oppia/issues/131 - update for for visualizations
• https://github.com/DigitalCampus/django-oppia/issues/130 - updated docs for new util files
• https://github.com/DigitalCampus/django-oppia/issues/10 - fix icon url in awards API
Change Log for v0.2.x
v0.2.15 - 21-Mar-2014
• Fix https://github.com/DigitalCampus/django-oppia/issues/138 - add login/register/download to tracker
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
v0.2.14 - 20-Mar-2014
• Fix https://github.com/DigitalCampus/django-oppia/issues/133 - add visualizations page
• Fix https://github.com/DigitalCampus/django-oppia/issues/137 - add lang to tracker model
• Fix https://github.com/DigitalCampus/django-oppia/issues/136 - update visualization to include langs
v0.2.12/13 - 18-Mar-2014
• Fix https://github.com/DigitalCampus/django-oppia/issues/134 - add country full name
• Fix https://github.com/DigitalCampus/django-oppia/issues/135 - exclude staff hits
v0.2.10/11 - 17-Mar-2014
• Fix for urllib/urllib2
v0.2.8/9 - 17-Mar-2014
• Fix https://github.com/DigitalCampus/django-oppia/issues/127 - add IP location cache table
• Fix https://github.com/DigitalCampus/django-oppia/issues/125 - add optional data to media model
• Fix https://github.com/DigitalCampus/django-oppia/issues/113 - not removing old course versions
• added util to update the carto db map
• added util to tidy up course upload dir
v0.2.7 - 14-Mar-2014
• Fix https://github.com/DigitalCampus/django-oppia/issues/121 - error in Excel export
• Add https://github.com/DigitalCampus/django-oppia/issues/123 - updates to tag model
v0.2.6 - 8-Mar-2014
• Fix https://github.com/DigitalCampus/django-oppia/issues/90 - split points/badges
• Fix issue with badges API
• Limit number of records returned with points API
v0.2.5 - 4-Mar-2014
• New required library - django-taglib
• Added ip2location.py utility script
• Fix https://github.com/DigitalCampus/django-oppia/issues/83 - adding profile gravatar
• Fix https://github.com/DigitalCampus/django-oppia/issues/105 - option to export activity logs to csv/xls
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
• Fix: https://github.com/DigitalCampus/django-oppia/issues/100 - ensure full list of tags/courses returned
• Fix: https://github.com/DigitalCampus/django-oppia/issues/111 - don’t assign badges for creating quizzes
• Fix: https://github.com/DigitalCampus/django-oppia/issues/114 - use UUID for trackers
• Fix: https://github.com/DigitalCampus/django-oppia/issues/110 - quizprops post api
• Fix: https://github.com/DigitalCampus/django-oppia/issues/106 - cache activity/seciton title in tracker table
Change Log for v0.1.x
• Fix: https://github.com/DigitalCampus/django-oppia/issues/109 - error uploading courses
• Update documentation for AWS machine image
• Fix: https://github.com/DigitalCampus/django-oppia/issues/103
• Use updated versions of Django, TastyPie and South
• Fix: https://github.com/DigitalCampus/django-oppia/issues/98 - use XSD for validating uploaded packages
• Fix: https://github.com/DigitalCampus/django-oppia/issues/91 - don’t return full quiz object
• Fix: https://github.com/DigitalCampus/django-oppia/issues/89 - exclude description questions from display
• Fix: https://github.com/DigitalCampus/django-oppia/issues/57 - order quizzes by section/activity
• Fix:
graphs/leaderboard/activity detail
• Fix: https://github.com/DigitalCampus/django-oppia/issues/84 - new local settings
• Fix: https://github.com/DigitalCampus/django-oppia/issues/85 - add resources to activity graph
• Fix: https://github.com/DigitalCampus/django-oppia/issues/77 - return is_draft with course resources
• Fix: https://github.com/DigitalCampus/django-oppia/issues/60 - fix Tag API so only returns course relevant for
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
• Fix: https://github.com/DigitalCampus/django-oppia/issues/72 - Tracker API error when more than one media
with same digest
• Really fix: https://github.com/DigitalCampus/django-oppia/issues/68 - add fixtures to PyPi package
• Fix: https://github.com/DigitalCampus/django-oppia/issues/71 - adding tracker data
• Fix: https://github.com/DigitalCampus/django-oppia/issues/68 - add fixtures to PyPi package
• Upgrade to use more recent version of TastyPie (0.9.16)
• Fix: https://github.com/DigitalCampus/django-oppia/issues/67
• Fix: https://github.com/DigitalCampus/django-oppia/issues/49
• Fix: https://github.com/DigitalCampus/django-oppia/issues/63
• Handle adding baseline quizzes/activities: https://github.com/DigitalCampus/django-oppia/issues/56
• Bug fix returning metadata in Tracker API
• New local setting to allow only staff status to upload courses: https://github.com/DigitalCampus/django-oppia/
• Points for watching media now determined by how many mins of the video has been watched: https://github.
• New local setting to allow only points to be turned on/off on the server: https://github.com/DigitalCampus/
• New local settings to determine which metadata should be collected from the phone: https://github.com/
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
• Fix cohort editing form: https://github.com/DigitalCampus/django-oppia/issues/54
• In cohort admin page show participants in inline tabular form
• Show recent activity as a graph rather than just numbers for today and last week
• Begin to add teacher monitoring pages
• Add option to turn self registration on or off: https://github.com/DigitalCampus/django-oppia/issues/2
• Add option for added Google Analytics: https://github.com/DigitalCampus/django-oppia/issues/1
• Fix: https://github.com/DigitalCampus/django-oppia/issues/46
• Added script for scanning dir of video files to create the tags: https://github.com/DigitalCampus/django-oppia/
• Also added auto creation of images for video files: https://github.com/DigitalCampus/django-oppia/issues/45
• Fix awarding points with badges: https://github.com/DigitalCampus/django-oppia/issues/41
• Fix: https://github.com/DigitalCampus/django-oppia/issues/13
• Add version number to footer
• Add views for quiz results
• Fix: https://github.com/DigitalCampus/django-oppia/issues/18
• Added unit tests for QuizAttempt https://github.com/DigitalCampus/django-oppia/issues/39
• Fix: https://github.com/DigitalCampus/django-oppia/issues/42
• Add default badges data
• Fix error in running cron script and awarding badges
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
• Begun to add unit tests
• More info on courses page about current activity
• Fix: https://github.com/DigitalCampus/django-oppia/issues/19
• Add a max upload file size (https://github.com/DigitalCampus/django-oppia/issues/8) - this prevents users uploading large course files which may make it difficult for end users to download on slow connections
• Updated mobile scorecard page
• Added extra info on Django admin pages (https://github.com/DigitalCampus/django-oppia/issues/14)
• Initial release (all previous versions were for alpha testing)
2.15.2 OppiaMobile Client App (Android)
OppiaMobile Android App Change Log
To see the upcoming feature developments and bug fixes, please refer to the monthly milestones on GitHub
v65 (6.5.0) - not yet released
v64 (6.4.0) - Released 25 Jan 2018
• 636: Add message when course cannot load due to parsing errors - https://github.com/DigitalCampus/
• 622: Add option to turn off notifications (eg new courses etc) - https://github.com/DigitalCampus/
• Improve app customisation process - https://github.com/DigitalCampus/oppia-mobile-android/pull/640
• 611: NumberFormatException when connection/response timeout values are very large - https://github.com/
• 613: Check that the download via PC is gives the correct location for copying the files to - https://github.com/
• 617: Add lang pack for Arabic - https://github.com/DigitalCampus/oppia-mobile-android/issues/617
• 648: Reduce no clicks through to content when launching from other app - https://github.com/DigitalCampus/
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
• 646: Trim server url before it’s checked to be a well formed url - https://github.com/DigitalCampus/
• 644: Update acknowledgements page - https://github.com/DigitalCampus/oppia-mobile-android/issues/644
• 645: When retaking a quiz the icon for playing media appears for all questions - https://github.com/
• UI improvements - https://github.com/DigitalCampus/oppia-mobile-android/pull/649 and https://github.com/
v63 (6.3.0) - Released 14 Jun 2017
• 616: Display drag and drop questions - https://github.com/DigitalCampus/oppia-mobile-android/issues/616
• 626: Add new logo - https://github.com/DigitalCampus/oppia-mobile-android/issues/626
• 599: Full-Screen Images - https://github.com/DigitalCampus/oppia-mobile-android/issues/599
• 630: Update info for BIND_DEVICE_ADMIN - https://github.com/DigitalCampus/oppia-mobile-android/
v62 (6.2.0) - Released 28 Feb 2017
• 600: Feedback field disappears on Quiz Feedback ListView - https://github.com/DigitalCampus/
• 603: Pre-Test quizzes not showing correct title - https://github.com/DigitalCampus/oppia-mobile-android/
• 610: App crashing issues on password reset and video download - https://github.com/DigitalCampus/
• 605: OppiaMobile server setting - https://github.com/DigitalCampus/oppia-mobile-android/issues/605
• 606: Course icons not scaling correctly - https://github.com/DigitalCampus/oppia-mobile-android/issues/606
• 272: Add lang pack for French - https://github.com/DigitalCampus/oppia-mobile-android/issues/272
v61 (6.1.1) - Released 30 Jan 2017
• 607: App crashing on login - https://github.com/DigitalCampus/oppia-mobile-android/issues/607
v60 (6.1.0) - Released 14 Jan 2017
Note: This releases implements a properties configuration file, eg for the Mint API key and other settings for the app.
• 527: Improved error messages when connecting to Oppia server - http://github.com/DigitalCampus/
• 510: Invalidate user apiKey? - http://github.com/DigitalCampus/oppia-mobile-android/issues/issue/510
• 526: In quiz activity - if user has passed then show option to continue rather than retake - http://github.com/
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
• 459: Allow max no attempts for quizzes - http://github.com/DigitalCampus/oppia-mobile-android/issues/issue/
• 555: ListPreference requires an entries array and an entryValues array - http://github.com/DigitalCampus/
• 552:
Error on logging in :
• 480: How to pre-load accounts onto the device - http://github.com/DigitalCampus/oppia-mobile-android/issues/
• 559: java.lang.IllegalStateException:
Activity has been destroyed - http://github.com/DigitalCampus/
• 477: Look at what would be needed to allow categories of courses - http://github.com/DigitalCampus/
• 564: App shuts down when having installed a course by copying onto the sd card - http://github.com/
• 549: Adding BugSense/Mint API key in non-Git file - http://github.com/DigitalCampus/oppia-mobile-android/
• 574: Restricting no attempts at quiz - unlimited attempts still possible - http://github.com/DigitalCampus/
• 565: Show message when all video files downloaded and no more to get - http://github.com/DigitalCampus/
• 566: Media download page - ordering & add some extra info - http://github.com/DigitalCampus/
• 573: In course download list show information about who published the course - http://github.com/
• 575:
Course download page - allow text overflow/wrapping - http://github.com/DigitalCampus/
• 562: java.lang.IllegalStateException: setSelectedNavigationIndex not valid for current navigation mode - http:
• 560: Option to download all the media - http://github.com/DigitalCampus/oppia-mobile-android/issues/issue/
• 317: How to include some layout (html) in quiz questions - http://github.com/DigitalCampus/
• 274: Add lang pack for Spanish - http://github.com/DigitalCampus/oppia-mobile-android/issues/issue/274
• 590: Downloading an updated course - http://github.com/DigitalCampus/oppia-mobile-android/issues/590
• 587: Larger margin between quiz response options - http://github.com/DigitalCampus/oppia-mobile-android/
• 539: Log when a user tries to open a media file but it’s not on the phone - http://github.com/DigitalCampus/
• 589: When changing settings that affects the menu options, they don’t update until next open of the app http://github.com/DigitalCampus/oppia-mobile-android/issues/589
• 594: Enable logout from homepage should be true by default - http://github.com/DigitalCampus/
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
• 595: Update logout message as logs no longer lost on logout - http://github.com/DigitalCampus/
• 586: Supported media file types - https://github.com/DigitalCampus/oppia-mobile-android/issues/586
v59 (6.0.2) - Released 7 May 2016
• Hotfix for video player
v58 (6.0.1) - Released 6 May 2016
• 490: Add option to show the logged in user - http://github.com/DigitalCampus/oppia-mobile-android/issues/
• 421: context menu of the main activity into a drawer - http://github.com/DigitalCampus/oppia-mobile-android/
• 360: Look at how to reorganise menu options - http://github.com/DigitalCampus/oppia-mobile-android/issues/
• 538: Add mp3 as supported file type - http://github.com/DigitalCampus/oppia-mobile-android/issues/issue/538
• 338: On download courses page if no connection then close activity too - http://github.com/DigitalCampus/
• 533: Update drawer header so the logo is pulled from the one specified for the app - http://github.com/
• 529:
Show message when no
• 534:
Display message in scorecard if no courses installed - http://github.com/DigitalCampus/
• 540: Occassional Null Pointer Exception on UIUtils.java:155 - http://github.com/DigitalCampus/oppia-mobileandroid/issues/issue/540
• 514: Copy in the mquiz-jar classes - rather than having as separate jar - http://github.com/DigitalCampus/
• 531: Permissions management in Android M - http://github.com/DigitalCampus/oppia-mobile-android/issues/
Note: Starting with the release of the OppiaMobile Android App v57 (6.0.0), we will be moving to using Android
Studio as the supported development environment. This is an important note since the project structure will change
v57 (6.0.0) - Released skipped
Release skipped since we found some more issues with supporting SD cards in Android v4.4.2, this has been fixed in
release v58 above.
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
Previous Versions
Change Log for v5.x
v56 (5.5.0) - released 21 March 2016
• 473: Add options for display or not for the menu options - https://github.com/DigitalCampus/
• 418: Not connecting to get course download list - https://github.com/DigitalCampus/oppia-mobile-android/
• 463: Download media message not showing even when new courses are installed - https://github.com/
• 470: NullPointer causes crash on start up - https://github.com/DigitalCampus/oppia-mobile-android/issues/
• 472: In scorecard - allow users to jump directly to the quiz - https://github.com/DigitalCampus/
• 474: Allow setting up of admin password for accessing settings and course management - https://github.com/
• 483: Add setting to allow removal of register option in app - http://github.com/DigitalCampus/
• 488: Bug: viewing the course contents with the pre-test unpassed - http://github.com/DigitalCampus/
• 489: Check all main activities extend AppActivity - http://github.com/DigitalCampus/oppia-mobile-android/
• 471: Update activity task - give feedback if successful or not - http://github.com/DigitalCampus/
• 495: Update Mint SDK jar file - http://github.com/DigitalCampus/oppia-mobile-android/issues/issue/495
• 496: Simplify querying for getting quizzes passed - http://github.com/DigitalCampus/oppia-mobile-android/
• 481: Log out users after specified length of time - http://github.com/DigitalCampus/oppia-mobile-android/
• 465: Add user prefs table - instead of using prefs activity - to help with shared devices - http://github.com/
• 464:
Can’t start app with storage location set to external - http://github.com/DigitalCampus/
• 497: Update the main scorecard (for multiple courses) so matches the individual course scorecard - http://github.
• 482: How to enable more structured courses - http://github.com/DigitalCampus/oppia-mobile-android/issues/
• 512: Updated quiz jar file - http://github.com/DigitalCampus/oppia-mobile-android/issues/issue/512
• 498: Deal with deprecation of HTTP libraries - http://github.com/DigitalCampus/oppia-mobile-android/issues/
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
• 499: Pull in the Device Admin API option into the core code - http://github.com/DigitalCampus/
• 517: DB errors: java.lang.IllegalStateException: attempt to re-open an already-closed object - http://github.
• 424: Save searches into tracker - http://github.com/DigitalCampus/oppia-mobile-android/issues/issue/424
v55 (5.4.0) - released 24 Sept 2015
• 469: Check new scorecard calculating correctly - https://github.com/DigitalCampus/oppia-mobile-android/
v54 (5.3.0) - released 15 Sept 2015
• 342: Change to using inline download bars when downloading courses/media - https://github.com/
• 309: Run download media in background - https://github.com/DigitalCampus/oppia-mobile-android/issues/
• 177: Ability to select multiple media files for downloading - https://github.com/DigitalCampus/
• 444: Stop activity timer when user switches to another app - https://github.com/DigitalCampus/
• 445:
Quiz feedback - app can crash on screen rotation - https://github.com/DigitalCampus/
• 462: record in user table being recorded even when user is null - https://github.com/DigitalCampus/
• 458: Store extra login info to help with shared device usage - https://github.com/DigitalCampus/
• 307: Allow users to log back in without connection - https://github.com/DigitalCampus/oppia-mobile-android/
• 423: Not-started course from SearchActivity - https://github.com/DigitalCampus/oppia-mobile-android/issues/
• 323: Make sure trackers and quizzes submitted for all users each time the service runs - https://github.com/
• 451: Option to just download course activity file - https://github.com/DigitalCampus/oppia-mobile-android/
• 454:
QuizWidget saving the same tracker multiple times - https://github.com/DigitalCampus/
• 456: Add quiz scorecard - https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/456
• 457: Quiz results - store extra info to make it easier to calc results/scorecard - https://github.com/DigitalCampus/
Note: For some of the functionality now available in v54, the app must connect to an OppiaServer running at least
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
v53 (5.2.0) - released 12 June 2015
• 427: App crashing when changing server setting - https://github.com/DigitalCampus/oppia-mobile-android/
• 433: Add Urdu lang file from Bright Future app - https://github.com/DigitalCampus/oppia-mobile-android/
• 435: Update Bugsense to Mint jar - https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/435
• 437: Why are quiz results showing as 0% even when user has scored more - https://github.com/DigitalCampus/
• 431: Activity tabs with long titles aren’t shortening - so sometimes are unreadable - https://github.com/
• 436: On the course homepage, the activity titles are being shortened to only one line - https://github.com/
• 419: Remove dependency on ActionBarSherlock - https://github.com/DigitalCampus/oppia-mobile-android/
• 440: Replace the default activity icons with blank background - https://github.com/DigitalCampus/
• 449: Fail more cleanly when course files have been deleted from the sd card - https://github.com/DigitalCampus/
v52 (5.1.1) - released: 18 Mar 2015
• temporary fix for sd card issues
v51 (5.1.0) - released: 3 Mar 2015
• Now supports only v4 and above
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/391 - allow password reset using email
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/383 - quizzes getting recorded twice in
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/393 - implement URl activity
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/370 - Enable rotating of the course and
media download activities
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/375 - Check there is sufficient space on
device storage for downloading/moving files
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/376 - Give option in preferences to move
the storage location
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/334 - Fix action bar theme colours
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/203 - Allow screen rotation for tag select
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/349 - Reloading quiz/feedback after language change
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/409 - Updated scorecard
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/376 - preferences for storage option
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/349 - Reloading quiz/feedback after language change
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/368 - embed videos into quiz and feedback activities
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/349 - Reloading quiz/feedback after language change
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/366 - load images into gallery
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/349 - Reloading quiz/feedback after language change
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/229 - deprecated method for preferences
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/414 - speed up searching
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/398 - clicking on points/badges
v50 (5.0.1) - released: 30 Dec 2014
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/372 - static prefs
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/379 - setting to disable logout menu option
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/380 - setting to disable course delete
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/377 - setting to allow media download via
cellular network
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/367 - collapse keyboard between quiz
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/378 - Apply ViewHolder pattern in ArrayAdapters
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/388 - Require phone no on registration
• https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/390 - highlighting wrong categories on
tag select
v49 (5.0.0) - released beta version: 18 Nov 2014
• Fix https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/355 - preventing media being visible
to other apps
• Fix https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/371 - use custom media player
• Fix https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/352 - more reliable recording of media activity
• Fix https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/337 - move file storage to new location
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
Change Log for v4.x
v48 (4.1.2) - released: 1 Oct 2014
• Fix https://github.com/DigitalCampus/oppia-mobile-android/issues/issue/364 - prevent error when directory in
downloads dir
• Fix https://github.com/DigitalCampus/mquiz-jar/issues/issue/5 - prevent error when response title is an int rather
than string
2.15.3 OppiaMobile export block for Moodle
OppiaMobile Moodle Block Change Log
v2018022600 - Released 26 Feb 2018
• 189: Ensure the activity/course title and description is enslosed in CDATA - https://github.com/DigitalCampus/
v2018011800 - Released 18 Jan 2018
• Hotfix: Remove HTML entities in quiz question titles
• Add new stylesheet option
v2017042700 - Released 27 Apr 2017
• 173: Add option to select/enter the default language - https://github.com/DigitalCampus/moodle-block_oppia_
• 171: Exporting Drag and Drop questions - https://github.com/DigitalCampus/moodle-block_oppia_mobile_
• Add option for shuffling responses on multichoice questions
v2017022000 - Released: 20 Feb 2017
• 136: Don’t strip out all the HTML tags from quiz question text - https://github.com/DigitalCampus/
• 174: XML parsing error when the section/topic description/summary contains an image - https://github.com/
• 155: Extracting section title - missing custom name - https://github.com/DigitalCampus/moodle-block_oppia_
• 78: How to include some layout (html) in quiz questions - https://github.com/DigitalCampus/moodle-block_
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
v2017011400 - Released: 14 Jan 2017
Note: To install/update the block you will need to be running a recent version of Moodle (v3.1+). From May
2017, Moodle versions 3.0 and below will no longer be supported for general issues nor security fixes (see: https:
• 142: Change quiz export method - https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/
• 88: Non latin video filenames - https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/issues/
• 65: Give overall feedback in Quiz - https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/
• 125: Check version of PHP and cURL before trying to publish directly - https://github.com/DigitalCampus/
v2016082600 - Released: 26 Aug 2016
• 160: Replace some text in quiz questions and responses - https://github.com/DigitalCampus/moodle-block_
• 162: On exporting quizzes, options for quiz settings (export step 1) don’t appear - https://github.com/
v2016041301 - Released: 13 Apr 2016
• 135: Add course tags to the course XML file - https://github.com/DigitalCampus/moodle-block_oppia_mobile_
• 131: Error when exporting file activity when no description entered - https://github.com/DigitalCampus/
• 148: On export check the course shortname used - https://github.com/DigitalCampus/moodle-block_oppia_
v2016030400 - Released: 4 Mar 2016
• 118: In extracting media - not picking up newlines as blank space - https://github.com/DigitalCampus/
• 94: Better display format for quiz export settings - https://github.com/DigitalCampus/moodle-block_oppia_
• 25: Check still picks up media image - https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/
• 147: Page/Settings button disappeared - conflict with new styles applied? - https://github.com/DigitalCampus/
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
v2016022400 - Released: 24 Feb 2016
• 131: Error when exporting file activity when no description entered - https://github.com/DigitalCampus/
• 99: Allow blank topic titles - https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/issues/
• 126: Clearer info and handle better the section name and xml error when no activities/sections exported https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/issues/issue/126
• 127: In quizzes add option for max no attempts - https://github.com/DigitalCampus/moodle-block_oppia_
v2016020100 - Released: 1 Feb 2016
• 134: Add option to specify that the course activities must be attempted sequentially - https://github.com/
v2016011400 - released: 14 Jan 2016
• 129: Change link in bottom of block - https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/
• 116: Error in XML when section title has &nbsp; chars - and maybe others too - https://github.com/
• 130: Error in xml “failed to load external entity ” when trying to export course - https://github.com/
• 132: ‘output’ folder not automatically created - https://github.com/DigitalCampus/moodle-block_oppia_
v2015021800 - released: 18 Feb 2015
• https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/issues/issue/122 - save course tags
• https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/issues/issue/121 - make course download link clearer
• https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/issues/issue/123 - allow direct export to
OppiaMobile server
v2015011900 - released: 19 Jan 2015
• https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/issues/issue/117 - add support for Moodle url activities
• Fix issue with topic ordering in some courses
2.15. Change Log for OppiaMobile Platform Components
OppiaMobile Documentation, Release 0.10.0
v2014102900 - released: 29 Oct 2014
• Fix https://github.com/DigitalCampus/moodle-block_oppia_mobile_export/issues/issue/115 - preventing media
being visible to other apps
2.16 Troubleshooting an Oppia Implementation
2.16.1 Troubleshooting OppiaMobile App
Course doesn’t show up in the app course download list
• The course is marked as archived on the Oppia server. If a course is marked as archived, then it will not appear
for any user in the app. Check that the course is not marked as archived on the server.
• The course is marked as draft on the Oppia server. If a course is marked as draft then only admin/staff users will
be able to view it in the app. Either log in to the app as an admin/staff user, or remove the draft status from the
course in the server.
• The course has not been given any tags when being published. To view the course in the download courses part
of the app, each course must be given at least one tag when it has been published. If a course is updated and
re-published, then the tags must be given again (the original tags should be pre-filled in the course publishing
Cannot install app - check for system updates
First item to check is that the phone has all the available system updates installed. It is good practice to keep the
phones up to date with system updates, for bugs and security issues. To check if any updates are available, go to (from
the main Android settings): Settings -> About Phone -> System Updates. The exact sequence to check for updates
may vary slightly on different versions of Android.
Cannot connect to server - Longer Connection and Response Timeout
If you are on a particularly slow connection (for example when trying to register or log in the OppiaMobile app), the
connection may timeout before a response has been received.
In the Oppia app settings, you can increase the ‘connection timeout’ and ‘response timeout’. The default is 60000
(milliseconds, so one minute), so try to increase to 120000 (two minutes).
Cannot connect to server - Check Phone Date Setting
Check that the phone system date is set to the correct date. When connecting to an Oppia server using a secure
connection (SSL, https), the server certificates are valid for a particular date range. If the phone date is incorrect, and
falls outside the security certificate validity period, then the phone will refuse the connection.
Cannot connect to server - Check Server Name
Check that the server name (under the Oppia settings) is correct. The app should automatically add a trailing ‘/’ to the
server name if one hasn’t been entered already. By default most OppiaMobile implementations will try to use an SSL
connection, however some older versions of Android may not have the trusted certificate authority certificates installed,
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
in which case you may need to fall back to using a non-SSL connection, so replace ‘https://. . . ’ with ‘http://. . . ’ at the
beginning of the server name.
2.16.2 Troubleshooting OppiaMobile Server
Activity for a user doesn’t appear in the server
• The course has been updated. When a course is updated the unique references to the activities may change and
if the user has the old version of the course on their device, their version may not match the course version on
the server. Check that the users device has the most recent version of the course.
• For server performance reasons, the data used to generate the dashboard activity graphs are cached, and are only
updated when the server cron task is run. On installations based on the Oppia AWS machine the cron task is
pre-configured to run every 15 mins, so check that this is running correctly.
• If the users device is not connected to the internet (or it is pointing at the wrong OppiaMobile server) then the
users activity will not be reaching the Oppia server. In the app check that the server is set correctly (in menu >
settings > server) and that all the users activity has been sent to the server (menu > about > activity).
• If the user is an admin or staff user, then the activity is not shown in the dashboard graphs. Similarly, if the user
is set up as a teacher for the course, then their course activity is not reflected in the dashboard activity graphs
2.16.3 Troubleshooting Multilingual Content
OppiaMobile uses the in-built Moodle functionality for authoring courses in multiple languages.
For troubleshooting translations it is best to start trying to fix a single page, and ensuring that when the page is displayed
in Moodle, the language switching is working correctly. If the language switching is not working in Moodle, then it
will not work when the course is exported to Oppia either.
The Moodle documentation has some information on how to fix common problems.
Additional problems we have noticed:
Using mismatching single or double quotes
Be careful to check that the single or double quotes in the HTML tags are of matching types. In the examples below
(shown as large image as well as plain text), the first example uses a different type of double quotes. The multilanguage
filter in Moodle then cannot understand what is meant by the HTML code, and so fails to recognise that we are trying
to enter multilingual content.
Example 1 (incorrect):
2.16. Troubleshooting an Oppia Implementation
OppiaMobile Documentation, Release 0.10.0
Example 2 (correct):
In the Moodle inline HTML editor, it is very difficult to see that different types of quotes have been used. It is much
easier to notice if the page HTML is cut and pasted into a plain text editor (eg Notepad or similar) with a large font
size selected. Here is an example of mismatching quotes in the Moodle inline HTML editor:
The likely cause of having different types of quotes is from cutting and pasting from different sources.
Additional style attribute used in page and topic titles
For page and topic/section titles, when the multilang span tags include additional attributes, this seems to stop the
Moodle multilang filter functioning correctly, but applies to the titles only, not the page content.
Example 1 (does not work):
<span lang="ur" class="multilang" style="font-size: 1rem;">
˓→class="multilang" style="font-size: 1rem;">
</span><span lang="ar"
Example 2 (does work):
<span lang="ur" class="multilang">
</span><span lang="ar" class="multilang">
The difference being that the style="font-size:
1rem;" attribute has been removed.
2.17 Customisation
This section describes how you can do some basic customisation to the various components of OppiaMobile. Before
making any customisations, you should read our page on our use of GitHub - this will help you manage you code and
take advantage subsequent developments, bug fixes and new features implemented in the OppiaMobile code.
If you need and help or advice in getting set up and running, or any questions about the platform, then please post on
our OppiaMobile Google Groups forum.
2.17.1 Using GitHub
All the OppiaMobile source code (for all components) is hosted on GitHub. So before starting to make any customisations you should make yourself familiar with how git works and create your own account on GitHub (for free).
The key advantages to using a versioning system like GitHub include:
• Good tracking of what changes have been made, when and by whom
• Built in bug and issue tracker
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
• Ability for others to easily take a copy (fork) of the code for their own use and keep this up to date with new
features and developments in the core version.
You will find it extremely beneficial to create a proper fork of the code for the various OppiaMobile components
rather than just taking a basic copy of the code, since a fork will allow you to easily merge in future developments,
updates and bug fixes as well as submitting fixes and new features back into the core version for anyone else to take
advantage of.
A couple of links to help get you started:
• setting up Git - https://help.github.com/articles/set-up-git
• forking a repository (and keeping it up to date with the original): https://help.github.com/articles/fork-a-repo
Submitting changes to the core version
If you have made updates (new functionality, bug fixes etc) that you’d like to contribute back to the core version of
OppiaMobile, then please issue a “pull request”.
You can find info here on how to issue a pull request: https://help.github.com/articles/using-pull-requests/
Creating small, specific pull requests (matched to an issue in GitHub issue tracker), will make it much easier and
quicker (and also more likely) that your changes can be incorporated into the core version.
We’re keen to acknowledge those who have contributed to the development of OppiaMobile, so please also send us
your attribution information (name, organisation etc), so we can include you in the about/acknowledgements section
of the app.
2.17.2 OppiaMobile Django Server
Getting Started
Server Settings
Registration Form
Data Visualisations
2.17.3 OppiaMobile Export Block (Moodle)
Getting Started
Other Activity Types
2.17.4 Using stylesheets and javascript in your course
The Moodle oppia export block comes by default with a stylesheet and javascript file that will be applied to any courses
you export - so the stylesheet, javascript and related resources (images etc) will get exported to the course package
2.17. Customisation
OppiaMobile Documentation, Release 0.10.0
You can see an example of the standard stylesheet and javascript in use on our Moodle server at: http://moodle.
Creating your own style
To add a new style (or adapt the existing one), create an new css file in the <block>/styles directory, along with a new
directory for the resources (see the current folder structure).
2.17.5 OppiaMobile Android App
This section describes some of the basic customisations you may want to make when implementing your own version
of the OppiaMobile learning platform. Here we describe some of the more common requests for basic customisations,
however since the code is open source, you are, of course, free to make any customisations you like.
Before being able to create your own version of the OppiaMobile app, you should have an understanding of:
• Using Android Studio for development
• Basic understanding of the Android Java framework
• How to use GitHub for source code management
If you are completely new to any of the above, here are a few links to help get you started:
• Android development environment - https://developer.android.com/
• Android app development - getting started - http://www.vogella.com/android.html
• Git - http://git-scm.com/
• GitHub training (https://help.github.com/) and help (https://help.github.com/)
Getting Started
• Set up your development environment
• Create a fork of the oppia-mobile-android repository in GitHub
• Clone your new GitHub repository to your machine
• Create a project in Android Studio connected to this repository
• Ensure that you are able to compile and run (either on your physical Android phone or on an Android Virtual
Please ensure that you are able to compile and run the core version of the app before you start to make any changes to
the code.
Configuring your own version of the app
Once you’ve cloned the OppiaMobile Android app code and check you can compile and run the app on your device,
there are some changes you should make to the configuration.
The main reason to make these changes is so that you can:
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
• Submit your app to the Google Play Store - you won’t be able to submit an unchanged clone of the core version
to Google Play as the package name is already used.
• Receive automatic notifications of any errors your users may get when using the app
• Automatically have the app connect to your OppiaMobile server
Rename package
Update the package attribute on manifest tag in AndroidManifest.xml (keeping with the ‘reverse url’ type notation),
so for example, replace org.digitalcampus.mobile.learning with org.myorgname.myproject.
Also in AndroidManifest.xml, update the GCM permissions class names:
• update
<permission android:name="org.digitalcampus.mobile.
learning.C2D_MESSAGE" android:protectionLevel="signature" />
<permission android:name="org.myorgname.myproject.oppia.C2D_MESSAGE"
android:protectionLevel="signature" /> with org.myorgname.myproject.oppia
being the same as you used above.
• update
<uses-permission android:name="org.digitalcampus.mobile.learning.
C2D_MESSAGE" /> to <uses-permission android:name="org.myorgname.myproject.
oppia.C2D_MESSAGE" /> with org.myorgname.myproject.oppia being the same as you used
Update the app/build.gradle file to update the applicationId to be the same as you’ve used in the AndroidManifest.xml.
R class reference
The R.java is an Android dynamically generated class, created during build process to identify all the assets (from
strings to Android widgets and layouts), for usage in Java classes in your Android app. For each type of resource, there
is an R subclass (for example, R.drawable for all drawable resources), and for each resource of that type, there is
a static integer (for example, R.drawable.icon). This integer is the resource ID that you can use to retrieve your
To access your app resources, the R class is imported in your code, and it is declared under the app’s package name,
so we need to change all the references in the code to the R class to with new package name: to do so, replace
all instances of import org.digitalcampus.mobile.learning.R; with import org.myorgname.
This import is used in almost all the classes, so it will be easier to use a search and replace on the whole src/main/
java directory.
Google Cloud Messaging
The app uses the Google Cloud Messaging platform to receive push messages. You need to configure your own API
key from the Google developers console as explained in the Registering the app in GCM section of the documentation.
This is mandatory, as the google-services plugin checks that your package name and applicationId match
with the one that appears in the configuration JSON file.
If you are not going to use this functionalities, you can just edit the current google-services.json file in your
project app folder, replacing the value of the "package_name" property with your own package name. The current
configuration file is a dummy one, so no need to worry about it affecting your code.
2.17. Customisation
OppiaMobile Documentation, Release 0.10.0
Automatic error reporting
Update the MINT_API_KEY setting to the specific key you have generated for your app.
Default server connection
Assuming you have set up and installed you own OppiaMobile server, clearly you’ll want your users to connect to this
by default.
The core OppiaMobile android app is configured to point to our demonstration server (http://demo.oppia-mobile.org).
To have your version of the app automatically point to your server:
• Open the /res/values/untranslated.xml file
• Change the prefServerDefault string to be the url to your server
App title and welcome message
To update your app title, you just need to update the strings in app/res/values/strings.xml and app/res/
For the app title, you’ll need to update:
• app_name string in app/res/values/untranslated.xml
• title_welcome string in app/res/values/strings.xml
For updating the welcome message, you’ll need to update:
• strings
fragment_welcome_login_info in app/res/values/strings.xml
App logo
To use a different logo for your app, place your app logo in the drawable folder and update the following:
• In AndroidManifest.xml update android:icon="@drawable/dc_logo" to point to your logo (eg
• In org.digitalcampus.mobile.learning.application.MobileLearning class update
public static final int APP_LOGO = R.drawable.dc_logo; to point to you logo (eg
Settings and Defaults
The OppiaMobile Android app makes use of the Android build system to define at compile time some of the settings
for the project, so you don’t need to modify any source code. This is done by reading a file in the root of the project
called oppia-default.properties and creating all the necessary BuildConfig values.
If you want to overwrite any of this settings, create a new file named custom.properties and define any value
of the list below that you want to override. Note that you don’t need to define all the values again, simply the ones you
want to override, and the rest will use the default value.
IMPORTANT: The custom.properties file is ignored by Git in order to hide private configuration settings (like
API keys), so any changes you make to it will not be visible in your repository.
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
List of configurable values
• MINT_API_KEY (string): the Splunk Mint API key to use for the crash reports
• OPPIA_SERVER_DEFAULT (string): the initial Oppia server URL. By default, the demo server https://demo.
• SESSION_EXPIRATION_ENABLED (boolean): enable that the session of the current user expires after a
certain inactivity time. False by default
• SESSION_EXPIRATION_TIMEOUT (int): seconds of inactivity to expire a user’s session (only works if the
previous one is set to true)
• DEVICEADMIN_ENABLED (boolean): enable de remote admin functionality. False by default
Local admin settings (all false by default)
• ADMIN_PROTECT_SETTINGS (boolean): enable the admin password protection functionality
• ADMIN_PROTECT_COURSE_DELETE (boolean): protect course deletion by admin password
• ADMIN_PROTECT_COURSE_RESET (boolean): protect course reset by admin password
• ADMIN_PROTECT_COURSE_INSTALL (boolean): protect course installs by admin password
• ADMIN_PROTECT_COURSE_UPDATE (boolean): protect course update by admin password
Main menu configurations
• MENU_ALLOW_MONITOR (boolean): show the “Monitor option” in the main menu
• MENU_ALLOW_SETTINGS (boolean): show the “Settings” option in the main menu
• MENU_ALLOW_COURSE_DOWNLOAD (boolean): show the “Install courses” option in the main menu
• MENU_ALLOW_LOGOUT (boolean): show the “Logout” option in the main menu
• DOWNLOAD_COURSES_DISPLAY (int): max number of courses installed in wich the “download more
courses” button still appears in the main activity. By default, just one.
For changes to the design/layout such as changing the logo in the header, colour scheme etc., this should be fairly
straightforward and you should look at the following files in which to make these changes:
App icons and colors
To use a different logo for your app, place your app logo in the drawable folder and update the following:
• In AndroidManifest.xml update android:icon="@drawable/dc_logo" to point to your logo (eg
2.17. Customisation
OppiaMobile Documentation, Release 0.10.0
• In org.digitalcampus.mobile.learning.application.MobileLearning class update
public static final int APP_LOGO = R.drawable.dc_logo; to point to you logo (eg
To create this icon, you can rely on the Image Asset Studio tool that comes bundled with Android Studio to generate
all the necessary images in its density-specific folder. To use it, just select right-click in the res folder of your project
and select New > Image Asset. It will help you to create a Material design style icon based on your own image, and
to generate the drawable in all the needed resolutions.
Another image that contains the OppiaMobile logo is the one representing the default course icon for the courses that
don’t include a custom one. If you want to change this, you have to replace the drawable default_course.png
with the one you want. The general style for most of the courses in Oppia is to use a circle with a thin line border, so
using an image following that guideline will fit better.
If you want to go further with this customization, you can also change the default activity images with custom
ones, for example to make them tinted to your brand color. This images are inside the drawables folder, named
default_icon_activity.png and default_icon_quiz.png.
If you want to change the default green palette of the app to another set of colors that match better with your brand,
you can do it so by simply changing the colors_oppia.xml values resource. You can deduce from their names
where each color is used, but test the changes anyway until you acomplished the expected results.
Drawer design
You can change the design of the drawer menu as well, as it also contains the OppiaMobile logo and some green
The colors of the selected option on the drawer and the icons depend on the app colors (the colorPrimary value of
the style, and highlight_light in the colors resource), so once you have changed that it will apply automatically
to the drawer. The other thing you might want to modify is the drawer header design to use something more in line
with your brand.
To modify the header, open the drawer_header.xml file under the layout resources folder. There, first of all you
can change the main image that appears as the logo, changing the "source" parameter in the ImageView, that by
default uses the dc_logo drawable. We recommend using a squared image for this one, and something that has some
contrast with the background.
If the drawer background doesn’t fit with your brand image, you can change that also. To do that, replace the
drawer_header_bg drawable in your res folder with another image of your choice. This image can have the
resolution you want, but keep in mind that it will be cropped to fill the header space if the aspect ratio is different from
its container, so it is recommended to use an horizontal image with a similar aspect ratio as the existing one.
Also, once you have change your background, if the image you chose is too dark the text may be hard to read. If this
is your case, you can try changing the text color of some of the TextViews to a lighter one.
For more significant changes to the interface over and above changing the basic colour scheme and header etc, then
this will require more substantial updates and familiarity with the code base.
Preloading Courses
If you would like to distribute your app with some courses preinstalled, for example if you have a lot of phones you
would like set up with the same set of courses, then follow these steps:
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
• Place the course zip file(s) in the assets/www/preload/courses/ directory
• Add the following lines to the doInBackground method of org.digitalcampus.oppia.task.
Editor editor = prefs.edit();
editor.putBoolean("upgradeVXXX", true);
publishProgress("Upgraded to vXXX");
where XXX is the new version number. The first time the app is installed and run, the courses will be automatically installed.
• To subsequently distribute an updated version of the app (with new versions of the courses), then you will need
to add another code block (with new version number) to trigger the automatic installation of the updated/new
Migrating Android repository from Eclipse ADT to Android Studio
By the end of 2015, Google ended the development and official support for the Android Developer Tools (ADT) in
Eclipse. This specifically includes the Eclipse ADT plugin, with which the OppiaMobile Android app was developed.
As stated by Google, every app development project should be migrated to Android Studio as soon as possible.
It introduces some changes in terminology that need to be clarified:
• Project: A project in Android Studio is like a workspace in Eclipse. This would be entire project context.
Whatever you do in Android Studio, you do that in the context of a project. A project is an organizational unit
that represents a complete software solution. In fact, if you want to work in more than one app, you’ll have to
work in different instances of Android Studio.
• Module: A module in Android Studio is like a project in Eclipse. Each project has at least an app module that
contains the main application source code, resource files, and application level settings, such as the module-level
build file, resource files, and Android Manifest file.
• Dependencies: The biggest change is the use of Gradle to configure and build the project. Instead of having
library projects in the workspace, we define every dependency in our gradle files. The biggest advantage is the
possibility to add remote dependencies to the project as we will see later.
To learn more about Android Studio, see the overview in the Android Developers page: https://developer.android.com/
Project structure
The biggest barrier to migrate to Android Studio is that the folder structure of the project is different, so it can be
dangerous to the Git file history. To see the differences, lets have a look side by side to Eclipse and Android Studio
project structure.
|_ assets
|_ bin (hidden by .gitignore)
|_ gen (hidden by .gitignore)
|_ libs
2.17. Customisation
OppiaMobile Documentation, Release 0.10.0
|_ anim
|_ drawable
|_ ... etc
|_ org/digitalcampus/oppia....
Android Studio:
|_ app
|_ build (hidden by .gitignore)
|_ libs
|_ src
|_ test --> to implement unit testing
|_ main
|_ assets
|_ java
|_ org/digitalcampus/oppia...
|_ res
|_ anim
|_ drawable
|_ ... etc
|_ AndroidManifest.xml
|_ .gitignore
|_ build.gradle --> here we define project dependencies
|_ build.gradle --> here we define repositories and classpath dependencies
|_ settings.gradle --> here we include submodules (in our case, app)
|_ README.md
Migration process
Migrating from Eclipse ADT to Android Studio requires adapting to the new project structure and build system. To
simplify the migration process, Android Studio provides an import tool so you can quickly transition your Eclipse
ADT workspaces and Ant build scripts to Android Studio projects and Gradle-based build files.
The problem: Git might identify these files as simply moved/renamed, but unfortunately that doesn’t happen often,
so the Git file history of all the source code of the project can get lost in the process. Instead, to prevent any issue,
the best approach is to run the migration tool in a separate location and manually recreate the moves on the original
repository. Now we describe how to perform this migration step by step:
1. Download and install Android Studio: http://developer.android.com/intl/es/sdk/index.html
2. Open Android Studio and select “Import project (Eclipse ADT, Gradle, . . . ). Select the root OppiaMobile
repository folder and then set a new destination for the import (for example, temp-import). It should take less
than a minute and import the project without issues.
3. Once your import is complete, Android Studio displays an import summary, describing all the changes it’s made
to your project. This summary contains details about which files were moved during the import process, and
where you can find them in the new Android Gradle layout, plus information on any third party libraries or JAR
files that Android Studio has replaced with Gradle dependencies.
Chapter 2. Installation, Upgrading and Development
OppiaMobile Documentation, Release 0.10.0
4. By default, Android Studio searches for library equivalences with your current dependencies. If it doesn’t find
a maven library, it will simply copy the jar file that was there before. If any of these libraries were not detected,
replace manually with the following line(s):
• joda-time-2.2.jar: compile ‘joda-time:joda-time:2.2’
• androidplot-core-0.6.1.jar: compile “com.androidplot:androidplot-core:0.6.1”
• picasso-2.5.2.jar: compile ‘com.squareup.picasso:picasso:2.5.2’
• okhttp-3.1.2.jar: compile ‘com.squareup.okhttp3:okhttp:3.1.1’
• mint-4.4.0.jar: compile “com.splunk.mint:mint:4.2”
Once you change this dependencies with its Gradle equivalent and make sure that the project compiles, you can delete
the related jar from the /app/libs/ folder
5. Now it’s time to apply the changes in the repository. First, create and checkout a new branch in the Eclipse
project location. This will make it easier to delete any changes if migration gets messy :)
6. Recreate the new source code structure, moving each file to where its new location will be. For Linux users, it
can be done by running these commands:
mkdir -p app/src/main/java
git mv src/com app/src/main/java
git mv res app/src/main
git mv assets app/src/main
git mv AndroidManifest.xml app/src/main
Make sure that the files are detected as a move by using git status (not needed if using git mv command)
7. Copy all the gradle files from the temporary imported project into the repository. For Linux users, assuming that
both the repo directory and the temporary imported project directory are in the same folder, it can be done by
running these commands:
temp-import/app/build.gradle oppia-mobile-android/app/
-r temp-import/gradle oppia-mobile-android/
temp-import/build.gradle oppia-mobile-android/
temp-import/gradlew oppia-mobile-android/
temp-import/gradlew.bat oppia-mobile-android/
temp-import/settings.gradle oppia-mobile-android/
8. Edit the .gitignore file and add the new Android Studio files that can be ignored in the repository:
9. Finally, we can remove the old Eclipse files as they are no longer needed, remove the temporary project and
open the project with Android Studio. As we only copied the minimum possible from the other project, it will
detect it at first as a plain gradle project in the folder hierarchy selector, but once it scans the project it will
mark it as an Android project, generating all the IDE files associated (that we have added to the .gitignore file
manually). If everything is working properly, we can make the commit and start to get used to the new IDE :)
2.17. Customisation
OppiaMobile Documentation, Release 0.10.0
Chapter 2. Installation, Upgrading and Development
Creating your course in Moodle
If we have set up a course area for you on our Moodle server, then here are some basic instructions to help get you
started. If you would like to request us to set up an area in Moodle for you to test out your course in OppiaMobile
please contact us.
You should have received by email your username, password and link to your course area.
When you log into your course area you should see some example pages - these are there to help get you started and
demonstrate some of the features available. You can either update or remove these if you don’t need them.
When you’re on the course homepage press the ‘turn editing on’ button in the top right then you get the options to
add/edit activities/resources etc - for media essentially you’ll need to just to create “page resources”.
For information about specific aspects of course creation for OppiaMobile, see:
3.1 General guidelines for course content
Note: If you are copying and pasting content over from a Word or PDF document, you may find that extra (unnecessary) styling is also copied over into the HTML editor field in Moodle. To remove this use the ‘clear formatting’
option in the Moodle editor.
These are some general rules of thumb that we have found useful when developing courses so they ‘look good’ on the
mobile device, although clearly much depends on the screen size of the devices your learners are using:
• Number of sections/topics per course module: up to 10 sections/topics.
• Activity titles: we’ve found that about 4-6 words max will work best when displayed on the mobile.
• Number of activities per section/topic: up to 10 activities. There is no requirement for a particular order of
activity types.
• Course/Activity icons: although there are generic icons for each activity type, your course will look more
attractive if you can add custom icons/images for each activity.
OppiaMobile Documentation, Release 0.10.0
• Length of page content: as a rough guide approx 200-250 words is the most that will fit on each page, otherwise
the user may need to do a lot of scrolling.
• Images: try to keep the filesize of images down as far as possible, although the course/activity icons are automatically resized on export, other images contained within the activities are not. Best to keep an image files
below about 400px wide.
• Media content: long videos may be uncomfortable to view on a small screen, we suggest keeping videos quite
short (less than 3-5 mins). Consider splitting you videos into different parts if you really need to include long
video content. As with images, try to keep the video filesize as low as possible, users are unlikely to need very
hi-res versions of videos if they are viewing on a 4 screen. We use Handbrake to convert our videos, using the
‘Android’ preset – this always gives a good balance between video quality and the filesize.
• File resources: we discourage including long pdf files or presentation type files for 2 main reasons, (1) it can be
hard to read long pdfs/presentations on smaller screens and (2) users may need to have specific apps installed to
open these types of files.
3.2 Activity types supported
The only Moodle activity types supported in OppiaMobile are:
• page resources
• file resources
• feedback activities
• quiz activities
If you add any other Moodle activities or resources types, these will just be ignored when the course is exported.
3.3 Using images in your course
3.3.1 Adding course icon/image
Go to your course settings page in Moodle and upload an image into the course summary field – this image will then
be used as your OppiaMobile module image/icon. If you upload more than one image into this field, then the first one
will be used.
3.3.2 Embedded images
Any images you embed into Moodle page resources will also be exported. To ensure they will display well on the
mobile device without horizontal scrolling, it is best to keep the maximum width of any uploaded images to be around
250px. This also assists in keeping the course module filesize down and makes it easier for users to download your
3.3.3 Adding activity icons/images
You can add a custom image/icon for each activity. For page resources go to edit your page and upload your image/icon
in the description field. For quiz activities, go to edit your quiz settings and upload you image/icon into the introduction
field. All images will be automatically resized on export, so you don’t need to worry about figuring out the exact image
dimensions/size. If you don’t specify a custom icon/image for your activity, but your activity includes an embedded
Chapter 3. Creating your course in Moodle
OppiaMobile Documentation, Release 0.10.0
image in the content, then this embedded image will be used as the icon. If there are no embedded images and no
custom icon, then a generic icon will appear for your activity.
3.4 Adding quizzes
Add all your questions as standard Moodle quiz questions and they will be exported to run as quizzes on the mobile
device. Note that only questions which can be marked automatically can be exported, so any essay questions will not
be exported as these require manual marking.
Essentially the question types supported are:
• any question supported by the Moodle GIFT format (with the exception of essay) can be exported to OppiaMobile
• Drag and drop questions (new to core Moodle 3.1) are also supported
3.5 Using Media Content in OppiaMobile Courses
When a user installs a course containing media content (audio/video), the actual media aren’t included in the course
download content. The reason for this is that media files tend to be very large and users on slow connections are
unlikely to be able to download large media files.
If a course contains media files that aren’t available on the users phone, on the app homepage a message will appear
that some media content is missing.
3.5.1 How to embed media files in OppiaMobile courses
1. Optimize your media for playback on mobile devices. Users viewing videos on a 4 or 5 inch screen generally
don’t need really high quality as you may want to use if projecting the video. At Digital Campus, we usually
convert videos into .m4v format using Handbrake (https://handbrake.fr/ - an open source tool and works on most
2. Upload the converted media to the internet, so it’s available for anyone to directly download the full media
file. If you have your own OppiaMobile server, you could just set up a web available directory on there. Digital
Campus for example has a plain website (http://downloads.digital-campus.org/media/) where we store the media
we’re using in our courses.
3. Once your media has been uploaded to a server, you can use the Media Embed Helper page to generate the
content to paste into Moodle.
3.5.2 Many media files to embed?
You use the utility script /oppia/utils/media_scan.py to generate the embed code blocks for a whole directory of media
files. This will also automatically generate a set of screenshots from the video that you can use for embedding.
3.5.3 How can users get the media files
There are two options for getting the media content onto users phones:
1. Download the media files directly onto the users SD card. This is most likely the best option for projects which
are providing phones to users as the video files can be pre-loaded
3.4. Adding quizzes
OppiaMobile Documentation, Release 0.10.0
2. Download via the app. When the app flags up that a video file is missing, then the user can download directly to
their phone. This is only likely to be feasible to users who are connected to wifi. So by default users will only
be able to download video files directly if they are connected to a wifi network. This can be overridden in the
app settings to allow downloading of video files by allowing downloading using cellular network.
3.5.4 Manually creating the embed code
Should you really want to, you can also create the media embed code by hand:
1. Generate the md5 checksum for your media. All operating systems will allow you to generate an md5 checksum
of a file. The md5 is essentially a unique code to identify a file and it’s contents. We use this for the media,
so when a user download the media on their phone the app can verify they have the complete media (and no
broken/partial downloads) and the correct media.
2. Now you have md5 and the file uploaded to a server you can embed your media into your page on Moodle using
the following code:
[[media object='{“filename”:”ghmp-basic-skills-20121001.m4v”,
Just update the filename, download_url and digest (md5) to match your video file details.
3. You can replace the IMAGE/TEXT HERE with either some text or a screenshot of you video. When your course
is exported from Moodle, the export script will use the supplied information to ensure the user downloads the
correct video.
4. You optionally supply a filesize (in bytes) and length (in seconds) as follows:
[[media object='{“filename”:”ghmp-basic-skills-20121001.m4v”,
“length”:360}’]]IMAGE/TEXT HERE[[/media]]
Adding a filesize will inform the user how large the file is before they try to download and the length will be
used to determine whether a user has watched the whole video (or not).
3.6 Multilingual Interface and Content in the OppiaMobile App
For translating OppiaMobile, there are two separate areas to consider, the app interface and the course content.
3.6.1 App Interface
The language that the OppiaMobile app interface appears in (e.g. the buttons, menu items etc), is determined by
translation files directly included and compiled into the app. Which language file is used is determined by the language
that the whole phone interface is set to. This will default to English if the phone is set to a language that Oppia does
not have a language file for.
To add a new interface language:
Chapter 3. Creating your course in Moodle
OppiaMobile Documentation, Release 0.10.0
• Make copy of strings.xml from https://github.com/DigitalCampus/oppia-mobile-android/blob/master/res/
• Translate the English text (just the value, not the string name attribute).
• Create a new directory in the res directory called values-XX - where XX is the language code for the
• Copy the new strings.xml file into this new directory
3.6.2 Course Content
Providing translations of course content is completely separate from the application interface. This means that users
can select which language they would like to view the course content in, but without needing to change the phone
interface language.
When the app is first installed, the course language setting will default to the phone settings language. If a course isn’t
provided in the phone setting language, then it will default to the first language the course is provided in.
To create a course in multiple languages, when you are writing the course, just use the usual Moodle method for providing multilingual courses. You can find more information about this at: http://docs.moodle.org/en/Multi_language_
When the course is exported to OppiaMobile, it will then allow users to switch between languages in the OppiaMobile
3.7 Adding About/License information
If you have some general pages about your course you’d like to include, but you don’t want these to appear as course
activities (such as about, acknowledgements, license information etc), then you can add these as page resources in the
course summary/intro section of Moodle (‘topic 0). Any pages added here will be included in the menu options in
OppiaMobile when the user is viewing your course.
3.8 Testing your course on your mobile
If you would like to test out your course on your mobile but without publishing it and making it available for learners,
you can directly install the course on your mobile. Once you have edited your course content, export and download
the OppiaMobile package (from the Moodle block in your course). Then copy this zip file directly onto your phone
SD card. Copy it into the:
directory (there is no need to unzip the file) on your phone. When you start up the OppiaMobile app, it will automatically install the course for you to test how it looks and feels on a mobile device.
If you’d like to see an example of how we structured and set up the Antenatal Care course you can see this at:
Once you have some content etc that you’d like to test on your phone, press the ‘Export to Oppia Package’
button in the right hand column. At the end of the export output page, if it’s all exported successfully, there
will be a link to download the course .zip package. So you can download this and copy it to the /<storage_setting>/Android/data/org.digitalcampus.mobile.learning/files/download directory. The storage_setting path will
depend on where you have the app storage location set to.
3.7. Adding About/License information
OppiaMobile Documentation, Release 0.10.0
Then when you start up the OppiaMobile app on your phone it will automatically install the course and you can see
how it all looks on your phone/tablet.
Once you’re happy with how it all looks on your phone, you can upload the course to our server (http://demo.
oppia-mobile.org - same username/password that you use for the OppiaMobile client app) and it’ll be available for
anyone to download.
Note: Information on how to include stylesheets and javascript in your course
If you have any queries, comments or suggestions on how to improve these instructions, the course authoring process
or any other aspect of OppiaMobile, please post them on the OppiaMobile Google Forum
Chapter 3. Creating your course in Moodle
This documentation details the permissions for the various components of OppiaMobile.
4.1 Course Development and Publishing Permissions
4.1.1 Course development
Since courses for OppiaMobile are developed in Moodle, the permissions for creating courses in Moodle and which
users are able to collaborate on and edit courses are determined by Moodle’s permission system (see: http://docs.
4.1.2 Publishing courses for OppiaMobile
Exporting for testing
Any user in Moodle may export a course to the OppiaMobile .zip format - which can then be copied directly onto the
phone for testing.
Course Publishing - Initial
Once a course has been developed and is ready for publishing onto an OppiaMobile server, only those users with
permission to upload courses to the OppiaMobile server may publish (see the server permissions page).
Course Publishing - Updating
If a course has already been published and it is then updated and requires re-publishing to the OppiaMobile server, only
the user who originally published the app may update it (the original course owner). If necessary, in the OppiaMobile
server, you can change the course owner from the Django admin pages.
OppiaMobile Documentation, Release 0.10.0
4.2 OppiaMobile App Permissions
In the OppiaMobile client (phone) app generally all users have the same functionality and permissions. The only
difference is those users who are teachers who can the monitoring pages directly within the app. For admin and staff
users to see these monitoring pages, they need to be explicitly assigned the teacher role in the appropriate cohorts and
4.2.1 Restricting app permissions
There may be some cases (for example when using shared devices), where you may want to prevent app users from
installing or removing courses, or change the particular app settings. The app has the option to set an admin password,
which will then restrict access to options such as installing/removing courses. To enable this, go to the settings in the
app, check the box to “protect admin actions with password” and enter an admin password.
4.3 OppiaMobile Server Permissions
There are various permissions associated with users in OppiaMobile, some based on the default Django users system
and others based on extra permissions the user has been specifically given.
• Admin User - this is the standard Django superuser (https://docs.djangoproject.com/en/1.8/topics/auth/default/)
- a typical user with this role would be a system/server administrator
• Staff - this is the standard Django staff user (https://docs.djangoproject.com/en/1.8/topics/auth/default/) - a typical user would be a project manager/officer, college or ministry staff, essentially users who need to access all
the data/reports within the server, but not necessarily responsible for the technical maintenance or server level
• Teachers/Students - in Django permissions terms, both teachers and students are standard users. The only
difference between them is that a teacher has been assigned the teacher status to a particular cohort of students.
A cohort is just a group of teachers and students assigned to a particular set of courses. A user may have the
role of teacher on one set of courses, but then be a student on other courses.
Chapter 4. Permissions
OppiaMobile Documentation, Release 0.10.0
4.3.1 Permissions on the OppiaMobile Server dashboard:
Access Django Admin
Upload Course
Bulk Upload Users
View Cohorts
Add New Cohort
Edit Existing Cohort
View course list
View draft courses
View course recent activity
View course activity detail
View course quizzes
View student activity (all activity)
View student activity (for specific course)
View student activity (for specific cohort)
View server level analytics
Admin User
No (1)
No (2)
Yes (3)
Yes (5)
Yes (6)
Yes (6)
Yes (6)
No (6)
Yes (6)
Yes (6)
No (2)
No (4)
Yes (5)
No (7)
No (7)
No (7)
No (7)
No (7)
No (7)
1. Staff are able to access the Django admin URL, however they do not have permissions to view any of the data
models or actual data through this
2. Any user (teacher or student) may be given permissions to upload courses by changing the ‘can upload’ field in
their UserProfile to be true.
3. Teachers may only view cohorts that they are teachers in.
4. Students may view their own activity within a cohort
5. Students and Teachers may view all the courses available on the server, except those that are still in draft stage
6. A teacher may only view the activity for courses they are assigned to be teachers on, and then only for the
students in the cohorts they are teachers in.
7. Students may see their own activity within a course or cohort - but not anyone elses
4.3. OppiaMobile Server Permissions
OppiaMobile Documentation, Release 0.10.0
Chapter 4. Permissions
Dashboard Guide
The OppiaMobile server web interface allows you to:
• monitor the activity and progress of your learners.
• manage users and permissions
• manage courses and cohorts
Any user with an OppiaMobile account can log into the dashboard, but what they are able to view will depend on their
permissions (see OppiaMobile Server Permissions).
5.1 User and Permissions Management
5.1.1 Add a new user
1. Just register a new user (using the ‘Register’ link in the menu bar)
1. From the menu bar, select ‘Admin’ > ‘Django Admin’
2. Select ‘Users’ under the ‘Authentication and Authorization’ section
3. Select ‘Add a new user’ and complete the form
5.1.2 Bulk upload users
1. From the menu bar, select ‘Admin’ > ‘Upload users’
2. Prepare a CSV file with all the user info. You can create a CSV file in Excel. Note that the column names are
case sensitive and must be written exactly.
3. Upload the file
OppiaMobile Documentation, Release 0.10.0
4. After processing you’ll receive a report detailing the results
5.1.3 Remove a user
Warning: Removing a user will delete all their activity logs and course progress. If you would like to stop a user
from accessing Oppia, but without deleting all their activity logs, then use ‘Block a user account’ instead.
1. From the menu bar, select ‘Admin’ > ‘Django Admin’
2. Select ‘Users’ under the ‘Authentication and Authorization’ section
3. Browse or search for the user and select
4. In the bottom left, click on ‘Delete’
5. You will be asked to confirm deletion of the user account
5.1.4 Block a user account
1. From the menu bar, select ‘Admin’ > ‘Django Admin’
2. Select ‘Users’ under the ‘Authentication and Authorization’ section
3. Browse or search for the user and select
4. Untick the ‘active’ checkbox
5. Click on the save button (bottom right)
You can unblock a user account in a similar way - just tick the ‘active’ checkbox instead.
5.1.5 Reset user password
Note: There is no way to find out what the original password was, as the passwords are stored in an encrypted format.
1. From the menu bar, select ‘Admin’ > ‘Django Admin’
2. Select ‘Users’ under the ‘Authentication and Authorization’ section
3. Browse or search for the user and select
4. Under the password field, follow the link and instructions to reset the password
5.1.6 Add/remove admin access permission
Warning: Admin accounts have permissions to add, edit and delete any or all of the data stored, as well as create
other Admin user accounts. Admin permissions should only be given to users who really need it, and consider
giving staff status instead.
1. From the menu bar, select ‘Admin’ > ‘Django Admin’
2. Select ‘Users’ under the ‘Authentication and Authorization’ section
Chapter 5. Dashboard Guide
OppiaMobile Documentation, Release 0.10.0
3. Browse or search for the user and select
4. Tick/untick the ‘superuser status’ checkbox
5. Click on the save button (bottom right)
5.1.7 Add/remove staff access permission
1. From the menu bar, select ‘Admin’ > ‘Django Admin’
2. Select ‘Users’ under the ‘Authentication and Authorization’ section
3. Browse or search for the user and select
4. Tick/untick the ‘staff status’ checkbox
5. Click on the save button (bottom right)
5.1.8 Add/remove permission to upload courses
1. From the menu bar, select ‘Admin’ > ‘Django Admin’
2. Select ‘User Profiles’ under the ‘Oppia’ section
3. Browse or search for the user and select
4. Tick/untick the ‘Can upload’ checkbox
5. Click on the save button (bottom right)
5.2 Course Management
5.2.1 Add a new course
Note: Usually courses would be added directly from Moodle during the export process
1. From the menu bar, select ‘Upload’
2. Select the course zip file that you exported from Moodle
3. Click on upload
4. Add or update the course tags and other information
5. Click save
5.2.2 View all courses
1. From the menu bar, select ‘Courses’
5.2. Course Management
OppiaMobile Documentation, Release 0.10.0
5.2.3 View courses for specific tag
1. From the menu bar, select ‘Courses’
2. From the drop down list of tags at the top of the page, select the relevant tag
3. The page will refresh and show just the courses for the selected tag
5.2.4 Update course information (tags etc)
Currently this should be done during the course export process in Moodle.
5.2.5 Publish a draft course
To publish a course that’s currently listed as ‘draft’, you can either republish the course from Moodle, unticking the
‘is draft’ option, or follow these steps:
1. From the menu bar, select ‘Admin’ > ‘Django Admin’
2. Select ‘Courses’ under the ‘Oppia’ section
3. Browse or search for the course and select it
4. Untick the ‘is draft’ checkbox
5. Click save
Similarly you move a course back to being a draft by ticking the ‘is draft’ option.
5.2.6 Download course package
1. From the menu bar, select ‘Courses’
2. Browse to the relevant course row
3. On the right hand side of the row, click ‘download course’
5.2.7 Archive a course
Note: Archived courses are no longer available for anyone to download, though users with the course installed in
their Oppia app will still be able to use the course as normal.
1. From the menu bar, select ‘Admin’ > ‘Django Admin’
2. Select ‘Courses’ under the ‘Oppia’ section
3. Browse or search for the course and select it
4. Tick the ‘is archived’ checkbox
5. Click save
Chapter 5. Dashboard Guide
OppiaMobile Documentation, Release 0.10.0
5.2.8 Delete a course
Warning: Deleting a course will remove all its activity logs, learner progress and quiz scores. If you just want to
make a course unavailable for download, then use ‘Archive a course’ instead.
Note: Deleted courses will (obviously) no longer be available for download. Though users with the course installed
in their Oppia app will still be able to use the course, however no points, activity, quiz scores will be recorded by the
1. From the menu bar, select ‘Admin’ > ‘Django Admin’
2. Select ‘Courses’ under the ‘Oppia’ section
3. Browse or search for the course and select it
4. In the bottom left, click on ‘Delete’
5. You will be asked to confirm deletion of the course
5.3 Cohort (Group) Management
5.3.1 Create a new cohort
1. From the menu bar, select ‘Cohorts’
2. Click on ‘Add a cohort’ button
3. Complete the form and click ‘Save’
5.3.2 Add/remove a course from a cohort
1. From the menu bar, select ‘Cohorts’
2. Browse to the row of the cohort you’d like to update
3. Select ‘Edit’
4. In the courses field, add or remove the relevant course shortname
5. Click ‘Save’
5.3.3 Add/remove a student from a cohort
1. From the menu bar, select ‘Cohorts’
2. Browse to the row of the cohort you’d like to update
3. Select ‘Edit’
4. In the students field, add or remove the relevant username
5. Click ‘Save’
5.3. Cohort (Group) Management
OppiaMobile Documentation, Release 0.10.0
5.3.4 Add/remove a teacher from a cohort
1. From the menu bar, select ‘Cohorts’
2. Browse to the row of the cohort you’d like to update
3. Select ‘Edit’
4. In the teachers field, add or remove the relevant username
5. Click ‘Save’
5.3.5 Delete a new cohort
1. From the menu bar, select ‘Admin’ > ‘Django Admin’
2. Select ‘Cohorts’ under the ‘Oppia’ section
3. Browse or search for the cohort and select it
4. In the bottom left, click on ‘Delete’
5. You will be asked to confirm deletion of the cohort
5.4 Activity and Progress Monitoring
5.4.1 View recent daily activity on server
The server dashboard homepage shows a graph of the daily activity for the last month:
5.4.2 View daily/monthly activity on server between specific dates
Under the daily activity graph on the server homepage, you can select a date range and interval (days or months) to
update the graph:
Chapter 5. Dashboard Guide
OppiaMobile Documentation, Release 0.10.0
Note: If you select the interval as ‘days’ and a long date range, it may take a long time to generate the graph especially if there has been a lot of activity on the server.
5.4.3 View server summary activity
1. From the menu bar, select ‘Analytics’ > ‘Summary Overview’
2. You will see a series of graphs and charts for the data from the last year (grouped by month), such as:
• monthly activity
• user registrations, both monthly and cumulative
• activity by country and language
• course downloads, both monthly and cumulative
• most active courses, in the last month
5.4.4 View activity for specific course
1. From the menu bar, select ‘Courses’
2. Browse to the course and click on its title
3. You will see the daily activity for the last month, and the option to select a date range and interval to view by.
5.4. Activity and Progress Monitoring
OppiaMobile Documentation, Release 0.10.0
5.4.5 View activity for specific cohort (group)
1. From the menu bar, select ‘Cohorts’
2. Browse to the relevant cohort.
3. You can either select to view the activity for the whole cohort (click on the cohort title), or you can view the
activity for a specific course within a cohort (click on the course title)
Chapter 5. Dashboard Guide
OppiaMobile Documentation, Release 0.10.0
5.4.6 View activity for specific user
Wherever you see a users name, you can click on their name to go directly to view their activity.
5.4. Activity and Progress Monitoring
OppiaMobile Documentation, Release 0.10.0
5.4.7 View activity for specific user on a particular course
From the user homepage, you can select which course to view the full detail from.
Chapter 5. Dashboard Guide
OppiaMobile Documentation, Release 0.10.0
5.4. Activity and Progress Monitoring
OppiaMobile Documentation, Release 0.10.0
Chapter 5. Dashboard Guide
Points and Badges
OppiaMobile awards points and badges to users based on their usage of the app and content.
Note: All the points and badges are awarded by the server, so if the user is offline, they will not see their points
increase, instead these points will be awarded once their device is next connected.
The points system is essentially a measure of engagement with the content - however it doesn’t really give a picture of
how much was understood. The badging provides confirmation that all the activities have been completed and that the
user has met at least the pass threshold for each quiz included in the course.
6.1 Points
Points are currently awarded as follows:
• 100 – creating an account
• 50 – downloading a course
• 20 – first time a quiz is attempted
• ? – depends on percentage score for a first attempt at a quiz. E.g. if the score is 75% on the first attempt, 75
points will be awarded
• 50 – bonus for getting 100% on first attempt at a quiz
• 10 – each subsequent attempt at a quiz (max. once per day per quiz)
• 10 – completing an activity (max. once per day per activity)
• ? – video views – points are awarded for how long the video has been have watched, 5 points for every 30
seconds watch, up to a maximum of 200 points. A bonus 20 points are given for the first time in a day a
particular video is watched
The points system is designed to encourage users to return to the courses regularly and engage in the activities.
OppiaMobile Documentation, Release 0.10.0
The points awarded for each activity can be customised in the server settings. To change the criteria for the awarding
of points, you’ll need to look at the signals.py file in the server as this determines the criteria for points.
6.2 Badges and Completing Courses
Every activity has the concept of ‘completedness’ and to be awarded a badge the user must complete every activity in
the course. The definitions of activities being completed of each activity type are given below:
• quiz - a quiz is completed if the user has obtained at least the pass threshold for the quiz.
• text/webpage - the page must be open for at least 3 seconds. Clearly this is not a very effective measure of
testing whether the user has fully read and understood the page content, however, currently it is the only way of
measuring that we currently have. We advise ensuring that the quiz questions provide an effective measure of
understanding the content.
• video - video/media files are embedded within text/web pages. The user must have the video running for at least
the length of the video. This may not correspond exactly to saying they have watched the whole video - for
example they may pause, fast-forward/rewind, and so have the video open for the required time, but not actually
have watched the video from start to finish.
• feedback - the user needs to answer all the questions
• file - the user simply needs to have opened the file
To change the criteria for assessing completedness of the activities, the getActivityCompleted() function for the relevant activity widget class in the app code will need to be updated.
Note: The badge awarding is performed by the Oppia cron task, so for badges to be awarded, please ensure that the
cron task is set up to run regularly.
6.3 Who can earn points/badges?
In the default settings:
• Admins and staff users do not earn points or badges for their activity in courses.
• Teachers do not earn points or badges in the courses they are teachers on
• If non admin or staff users are given permissions to upload courses, then they will not earn points or badges in
the courses they upload.
These defaults may be changed in the server settings.
Chapter 6. Points and Badges
7.1 Setting up the User Map Visualization
To set up the user map visualization to reflect the your users’ location on your server:
1. Create accounts on:
• ipaddresslabs
• geonames
• cartodb
2. Set up a table your CartoDB account with the following field names/types:
• lat (number)
• lng (number)
• total_hits (number)
3. Edit the oppia/utils/cartodb_update.py to update the cartodb_table variable with the name of
your table in CartoDB.
4. Run the following utility scripts:
• ip2location.py <IP Address Labs API Key> <Geonames username>
• cartodb_update.py <CartoDB Account Name> <CartoDB API Key>
5. (optional) If you would like the map to be automatically updated, you can set up a shell script and crontab task
to automatically run the 2 scripts from step 4.
6. Edit oppia/templates/oppia/viz/map.html to embed your map from CartoDB
Creating visualisations of the data in OppiaMobile is a work-in-progress, currently there are 2 main visualisations
OppiaMobile Documentation, Release 0.10.0
7.2 Summary Overview
This gives a one-page overview of the activity on your OppiaMobile server and can only be access by users with the
is_staff status. The summary overview page gives graphical representations of:
• User Registrations
• Activity by Country
• Course Downloads
• Course Activity
Note: All the statistics in the summary overview and map will exclude any activity made by users who have the
is_staff status.
7.3 User Map
This shows a map of the locations of the users and activity on your OppiaMobile server.
Note: By default this map shows the users from the http://demo.oppia-mobile.org server. To see a map of the users
on your server, you will need to configure this, see the user map setup instructions.
Chapter 7. Visualizations
OppiaMobile Training and Support
This set of documentation describes the various training sessions and workshops that Digital Campus has used on a
variety of projects to support the implementation of OppiaMobile.
8.1 Initial Workshop
This is the initial workshop we use when introducing users to Android and OppiaMobile. We usually run this over
2 days, much will depend on the previous knowledge your users may have of Android and also how much specific
information is needed to introduce them to your project/implementation.
8.1.1 Workshop Preparation and Set-up
Documents to prepare and print out:
• Participant workshop attendance sheet
• List of phones - to include IMEI no, serial no, phone no, Google account and Oppia account
• Smartphone and solar lamp/chargers user agreement and receipt forms (2 for each attendee - 1 for us and 1 for
them to keep)
• Participant consent form (2 for each attendee - 1 for us and 1 for them to keep)
• Contact sheet of all project members (name, role, phone no, email, location) (1 for each attendee)
• Training evaluation form (1 for each attendee to complete). To contain basic feedback questions/comments
about the training (what they liked, didn’t like, what they learnt, general feedback etc).
• Participant Surveys (Mobile phone usage and PNC & ANC skills / attitudes)
• Competency checklists
Many of these (those that don’t need signatures etc) can be completed in Excel - instead of printing out and completing
(and then needing to write everything up after).
OppiaMobile Documentation, Release 0.10.0
• Laptop & projector
• Flipchart paper
• Post it notes
• Pens and notebooks (for each attendee)
• Digital/phone camera
• Ideally a wifi connection (if not available then need to use data connection - if neither available then training
can still proceed, but some activities may need to be rescheduled for another time)
Setting up the Smartphones
Setting up the phones is likely to be time consuming (approx half hour per phone), so best to have this done as far in
advance as possible - especially if there may be any issues (eg in connection to install apps etc).
• Create an OppiaMobile account for each user
• Charge up phone
• When starting phone either create an new Google account or use an existing one
• From Google Play install:
– OppiaMobile - https://play.google.com/store/apps/details?id=org.digitalcampus.mobile.learning
– WhatsApp - https://play.google.com/store/apps/details?id=com.whatsapp
– ES file explorer - https://play.google.com/store/apps/details?id=com.estrongs.android.pop
• Start Oppia, log in with the user account and download all the required courses (or copy as zip files)
• Copy any required video resources onto the phone SD card.
• Record all the details of the user accounts used etc in the list of phones. Also mark inside the phone (using
permanent marker or similar) a unique identifier for the phone.
8.1.2 Session 1: Course Introduction
Time: 1 hour
• To introduce the project (what/why/how)
• To get to know the participants and for them to get to know the project team
• Ice breaker activity
• Presentation/description of the project and explain the roles of each member of the project team - hand out the
contact sheet
• Overview of the training sessions and what we’ll do (the sessions/activities below)
Chapter 8. OppiaMobile Training and Support
OppiaMobile Documentation, Release 0.10.0
• Explain the participants role in the project and our expectations of them (active participation and attendance at
workshop sessions, giving us honest and open feedback)
• Stress that we’re also looking to learn how to develop the system and content to help support them better, and
we’re open to feedback/suggestions etc (so don’t be shy!)
• Complete participants attendance sheet
• Sign consent forms
8.1.3 Session 2: A Primer on Mobile Health
Time: 1 hour
• To understand what is mobile health (mHealth)
• To introduce the local (e.g. Ministry of Health) strategy for mHealth
• To understand what is mobile learning and how can it be helpful to improve their teaching and learning
• Participants will fill-out a survey about their use of mobile phones and Internet.
• The facilitator will do an introduction to basic concepts of mhealth, the local strategy for mHealth and mobile
learning concepts.
• Group activity (3-4 people in each group). 15 minutes. Write down and discuss among them what they think
are the main challenges of HEWs training and their professional career development.
• Ask each group to share back to the whole group. Facilitators to identify common themes and ask questions
• Complete attendance sheet (if being run on different day to the other sessions)
• Analyse participants mobile phone and internet survey responses
• Complete a summary of the session discussions
8.1.4 Session 3: PNC & ANC challenges and barriers
Time: 1 hour
8.1. Initial Workshop
OppiaMobile Documentation, Release 0.10.0
• To get to know the current postnatal (PNC) and antenatal (ANC) coverage, challenges and barriers in Tigray
and Ethiopia
• To understand how HEWs can effectively contribute to improve PNC & ANC.
• To understand how MHealth can help improving maternal and child health
• Participants will fill-out a survey on their PNC & ANC skills and attitudes
• The facilitator will introduce the latest research and data on PNC & ANC in Ethiopia
• Group activity (3-4 people in each group). 15 minutes. Write down what are the main PNC challenges and
barriers in their districts and give ideas how they could improve it.
• At the end of the previous activity, ask each group to share back to the whole group. Facilitators to identify
common themes and ask questions
• Complete attendance sheet (if being run on different day to the other sessions)
• Analyse participants survey responses.
• Complete a summary of the session discussions
8.1.5 Session 4: A typical working day
Time: 1 hour
• To understand the typical workflow during their working day
• To understand how their day is broken down (how much time spent doing different activities)
• Group activity (3-4 people in each group). 15 minutes. Using a clock face drawn on flipchart paper, ask
the participants to write on what they usually do on a normal working day. Will include start/finish work
times, breaks etc. For tutors may include amount of time spent in the classroom, preparation time, doing
marking/assessment activities and general admin work, etc. For HEWs may include time spent seeing patients
at health post, time spent visiting patients at their homes, time spent doing admin work, time spent on training
activities, etc
• Can give an example first by one of the facilitators
• At the end of the activity, ask each group to share back to the whole group. Facilitators to identify common
themes and ask questions
Chapter 8. OppiaMobile Training and Support
OppiaMobile Documentation, Release 0.10.0
• Complete attendance sheet (if being run on different day to the other sessions)
• Take a photo of each of the flipcharts created
• Complete a summary of the session discussions / main ideas.
8.1.6 Session 5: Distribution of Phones
Time: 1 hour
• To assign phones to each participant
• Give overview of the phones - how do they differ from the basic phones they may be used to
• Explain our expectations of them - taking care of the phones, reporting and problems (including
loss/breakage/theft of phone), return of phones to the project if they leave/change job/role
• Explain what they can expect from us - prompt response to any issues raised, providing regular top-up (50 ETB
per month)
• Hand out phones and show participants how to turn them on
• Complete attendance sheet (if being run on different day to the other sessions)
• Complete the list of phones (if not already done)
• Sign the phone receipt form
• Complete a summary of the session main ideas.
8.1.7 Session 6: General Android Functions
Time: 2 hours
• To perform the following basic functions of the phone:
– Turning the phone on and off
– Plugging in the charger
– Replacing/adding sim card
– Switching between sim cards (assuming a dual sim phone)
– Make a phone call
8.1. Initial Workshop
OppiaMobile Documentation, Release 0.10.0
– Receive a phone call
– Adjust volume
– Send an SMS message
– Reply to an SMS message
– Add a contact (suggest they try adding the facilitators contact details)
• Follow up any questions/queries after their play/experimentation with the phones following session 5.
• Facilitators to demonstrate each of the above functions in turn and allow participants time to practice
• Encourage peer support - if there are strong participants who pick up the functions quickly - ask them to help
any participants who may be struggling.
• Complete attendance sheet (if being run on different day to the other sessions)
• Complete the competency checklist for each of the functions listed in the objectives. Facilitators to verify with
each participant that they can perform each function
• Complete a summary of the session issues/difficulties participants had.
8.1.8 Session 7: Care of phone and battery/file management
Time: 1 hour
• Understand how to take care of the phone
• How to manage battery life/charging
• How to manage files on the phone
• To perform the following functions of the phone: * Turn on /off wifi * Turn on/off data connection * Turn on/off
GPS * Turn on/off airplane mode * Manage camera images
• Explain the differences in smartphones vs basic phones, esp regarding battery life
• Explain that smartphones are more sensitive to dust/water/dropping than basic phones
• Explain the factors that can affect battery life
• Facilitators to demonstrate each of the above functions in turn and allow participants time to practice
• Encourage peer support - if there are strong participants who pick up the functions quickly - ask them to help
any participants who may be struggling.
Chapter 8. OppiaMobile Training and Support
OppiaMobile Documentation, Release 0.10.0
• Complete attendance sheet (if being run on different day to the other sessions)
• Complete the competency checklist for each of the functions listed in the objectives. Facilitators to verify with
each participant that they can perform each function
8.1.9 Session 8: Introduction to OppiaMobile
Time: 2 hours
• To open and navigate the courses in the app
• To use the following functions in the app:
– complete a quiz
– play a video
– logging in/out of the app
– viewing progress using the scorecard
• Understand what the points/badges mean
• Facilitators to demonstrate each of the above functions in turn and allow participants time to practice
• Encourage peer support - if there are strong participants who pick up the functions quickly - ask them to help
any participants who may be struggling.
• Facilitators to give overview of the points system - essentially that the more regularly they complete/access
activities, the more points they’ll get
• Explain the tracking information - so they’re aware that we get information about their activity
• Complete attendance sheet (if being run on different day to the other sessions)
• Complete the competency checklist for each of the functions listed in the objective 2
• Facilitators to verify with each participant that they can perform each function.
8.1.10 Session 9: How to install and use the courses in OppiaMobile
Time: 2 hours
8.1. Initial Workshop
OppiaMobile Documentation, Release 0.10.0
• To check that all participants have the relevant courses and video/media content installed
• To be able to install new courses
• To be able to navigate courses in OppiaMobile
• To be able to complete quizzes in OppiaMobile
• To understand how to use the additional content during their upgrade training course and afterwards
• Facilitators to verify that all participants have all 21 courses installed and all necessary media/videos
• Demonstrate how to install a new course
• Group activity (4-5 people in each group). 15 minutes. Discuss and write down what/ how could be the most
useful way of using the additional content during their training and afterwards.
• At the end of the previous activity, ask each group to share back to the whole group. Facilitators to identify
common themes and ask questions
• Complete attendance sheet (if being run on different day to the other sessions)
• Facilitators to verify that all the HEAT courses are installed
• Facilitators to check that all participants have installed another course
8.1.11 Session 10 : How to use other mobile applications (Apps)
Time: 1 hour
• To understand the idea of ‘apps’
• How new apps can be installed (using Google Play)
• How to use the internet on the phone (perform a search)
• Explain what apps are, and that there are many apps available. Note differences between paid for vs free
• Demonstrate a practice using Google Play store to search for apps and install a new one
• Demonstrate using the phone browser to do a search of the internet
• Encourage peer support - if there are strong participants who pick up the functions quickly - ask them to help
any participants who may be struggling.
• Explain that some apps will use their data connection/wifi
Chapter 8. OppiaMobile Training and Support
OppiaMobile Documentation, Release 0.10.0
• Complete attendance sheet (if being run on different day to the other sessions)
• Complete the competency checklist for each of the functions listed in the objective
• Facilitators to verify with each participant that they can perform each function
8.1.12 Session 11-A (Health workers): Oppia student scorecard and learning
progress monitoring
Time: 1 hour
• To teach HEWs on how to use the Oppia learning scorecard/ dashboard for their study progress monitoring.
• To get feedback from HEWs on what progress monitoring may be useful to them to help improving their learning
• Facilitators to demonstrate the Oppia learning scorecard / dashboard function and allow students time to practice.
• Facilitators to give overview of the points system - essentially that the more regularly they complete/access
activities, the more points they’ll get.
• Encourage peer support - if there are strong participants who pick up the function quickly - ask them to help any
participants who may be struggling.
• Complete attendance sheet (if being run on different day to the other sessions)
• Complete a summary of the session discussions / main ideas.
8.1.13 Session 11-B (Tutors): How to use the Oppia scorecard for learning progress
Time: 1.5 hours
• To teach Tutors / trainers on how to use the Oppia scorecard/ dashboard for their students progress monitoring.
• To get feedback from Tutors on what additional progress monitoring tools may be useful to them.
• To understand the different monitoring strategies to improve students learning process.
8.1. Initial Workshop
OppiaMobile Documentation, Release 0.10.0
• Open discussion on what tutors currently do to monitor their students learning progress. Identify students
learning monitoring challenges and barriers.
• Facilitators to demonstrate the Oppia scorecard / dashboard function and allow tutors time to practice.
• Facilitator to explain different monitoring methods tutors may use to improve students knowledge and skills
retention over time.
• Group activity (4-5 people in each group). Brain-storm and write down what / how could be the most useful
ways of monitoring students learning during their current training and afterwards.
• At the end of the previous activity, ask each group to share back to the whole group. Facilitators to identify
common ideas and ask questions
• Complete attendance sheet (if being run on different day to the other sessions)
• Complete a summary of the session main ideas/ topics.
8.1.14 Session 12: Closing/wrap-up
Time: 1 hour
• To summarise what we’ve covered during all the workshop sessions
• To respond to any outstanding questions/queries
• To explain / re-iterate the project process (and next follow-up workshop date)
• Give per-diems and mobile top-up cards
• Facilitators to explain and summarise the main topics discussed during this workshop
• General Q & A
• Fill-out and sign per-diems and mobile top-up cards receipt forms
• Complete attendance sheet (if being run on different day to the other sessions)
• Complete per-diems and mobile top-up card receipt forms
• Complete a summary of the workshop main action points.
Chapter 8. OppiaMobile Training and Support
OppiaMobile Documentation, Release 0.10.0
8.1.15 Competency Checklist
Session 6: General Android Functions
• Turning the phone on and off
• Plugging in the charger
• Replacing/adding sim card
• Switching between sim cards (assuming a dual sim phone)
• Make a phone call
• Receive a phone call
• Adjust volume
• Send an SMS message
• Reply to an SMS message
• Add a contact (suggest they try adding the facilitators contact details)
Session 7: Care of phone and battery/file management
• Turn on /off wifi
• Turn on/off data connection
• Turn on/off GPS
• Turn on/off airplane mode
• Manage camera images
Session 8: Introduction to OppiaMobile
• complete a quiz
• play a video
• logging in/out of the app
• how to see their progress using the scorecard
8.2 Content Development
This is designed to train content developers in how to create courses for OppiaMobile.
The training is designed to be run remotely (via skype/teleconference) with a small group of participants (max 5).
There should be a break of at least 2-3 days between each session, to allow participants time to complete the follow
up activities, practice what has been learned so far and review any recommended documentation.
Participants will require a good internet connection during the actual sessions.
8.2.1 Preparation and Set Up
• Ensure everyone has a Moodle account with necessary permissions.
• Create a test course area for each participant on Moodle and with permissions to export to an OppiaMobile
• Ensure everyone has an Android phone with the OppiaMobile app installed for testing.
8.2. Content Development
OppiaMobile Documentation, Release 0.10.0
8.2.2 Session 1: Overview of OppiaMobile and Creating First Learning Activity
Time: 1 hour
At the end of this session, participants will be able to:
• Describe the components of OppiaMobile platform and functions of each
• Describe the function of Moodle within the OppiaMobile platform
• Create a learning activity in Moodle and export to Oppia
• Add an image to the learning activity
• Introductions
• Describe key features of OppiaMobile (see: OppiaMobile Key Features)
• Describe architecture and components of OppiaMobile, especially Moodle for course authoring
• Access a Moodle course and turn editing on
• Basic course structure, levels of activities and how they get represented when exported to OppiaMobile
• Activity types supporting in OppiaMobile (see: Activity types supported)
• Adding a section/topic title
• Adding an HTML page activity
• Adding an image to the page
• Exporting to OppiaMobile server - options available on export
• Test viewing the course on the device
Follow up and preparation for next session
• Review full documentation for course development (see: Creating your course in Moodle).
• Add some more pages to their course and review how it appears in the OppiaMobile app.
8.2.3 Session 2: Adding a Quiz to a Course in OppiaMobile
Time: 1 hour
At the end of this session, participants will be able to:
• Create a quiz for OppiaMobile
• Create a baseline/pre-test
Chapter 8. OppiaMobile Training and Support
OppiaMobile Documentation, Release 0.10.0
• Review of previous session, any questions/queries
• Using Moodle quizzes and question bank
• Creating a true/false question
• Creating multiple choice question
• Creating other types of questions - and review of question types supported
• Exporting the course to OppiaMobile server and the export options
• How to add a baseline/pre-test so the user must complete before accessing the rest of the course
Follow up and preparation for next session
• Create more types of quiz questions
• Create a baseline/pre-test quiz for your course
8.2.4 Session 3: Embedding Video Content
Time: 1 hour
At the end of this session, participants will be able to:
• Describe how OppiaMobile handles video content
• Describe the factors that affect video content delivery in low-bandwidth environments
• Include a video in their OppiaMobile course
• Review of previous session, any questions/queries
• Describe how OppiaMobile handles video content (and why)
• Considerations for video formats and file sizes
• Adding a page for embedding video in Moodle
• Generating the embed code (using http://demo.oppia-mobile.org/content/video-embed-helper/)
• Inserting the embed code into Moodle
• Adding a video image
Follow up and preparation for next session
• Practice adding other videos, exporting the course and running on your device
• Review the OppiaMobile dashboard guide (Dashboard Guide)
• Review the OppiaMobile permissions documentation (Permissions)
8.2. Content Development
OppiaMobile Documentation, Release 0.10.0
8.2.5 Session 4: Activity Monitoring and Reporting
Time: 1 hour
At the end of this session, participants will be able to:
• Access the OppiaMobile dashboard
• Create new user accounts
• Create cohorts of teachers and students
• Review course and user progress in courses
• Review of previous session, any questions/queries
• Explanation of the function of the dashboard
• Walk through of the dashboard structure and navigation
• How to create new user accounts
• Permissions levels and how to assign them to users (refer to Permissions)
• Finding specific activity for a user and/or course
• Pre-defined reports
• Custom reporting
Follow up and preparation for next session
• Test creating new users on both the mobile device and server
• Test activity on their device and check the user/course progress in the dashboard
8.2.6 Session 5: Putting it all together & review
Time: 1 hour
At the end of this session, participants will be able to:
• Publish their course to make available for students
• Update courses once they have already been made live
• Prepare the next steps in their implementation
Chapter 8. OppiaMobile Training and Support
OppiaMobile Documentation, Release 0.10.0
• Review of previous session, any questions/queries
• How to publish and make available to your students
• Updating courses once already been made live
• Phone set up and initial user training
Advanced topics
There are several features that we haven’t covered during this training, these may be useful if you have specific
requirements in your implementation, for example adding multilingual content, using stylesheets and javascript within
your course pages, specific server settings for the criteria for awarding points and badges and generating custom
reports. Please discuss with us if you have any particular requirements in these areas.
8.3 Technical Training and Support (course under development)
This course is designed for local IT teams, to equip them with the skills needed to support and maintain an OppiaMobile implementation.
8.3.1 Prerequisites
• Background/qualification in IT
• Active internet connection
8.3.2 Learning Outcomes
At the end of this course, participants will be able to:
• Describe the platform components of OppiaMobile and the functions of each
• Install and set up the technical tools required for supporting Oppia
• Install and configure an OppiaMobile server instance on Amazon Web Services
• Install and configure Moodle with the OppiaMobile Export block
• Create a clone of the OppiaMobile app and submit to Google Play Store
8.3.3 Sessions
Session 1: Overview of components and technical tools
Time: 1 hour
8.3. Technical Training and Support (course under development)
OppiaMobile Documentation, Release 0.10.0
At the end of this session, participants will be able to:
• Describe the architecture and components of OppiaMobile
• Describe the frameworks and developer tools used for OppiaMobile
• Introductions
• Overview of the OppiaPlatform components - OppiaMobile Platform Architecture and Components
• Overview of developer tools used in supporting and maintaining OppiaMobile:
– Developer environments - Eclipse, PyCharm and Android Studio
– Git and GitHub
• Overview of frameworks used:
– Android
– Django
– Moodle
Follow up and preparation for next session
• Read up on OppiaMobile developer documentation - Installation, Upgrading and Development
• Install Git and read overview documentation - https://git-scm.com/
• Create account on GitHub - https://github.com/
• Check Github training (https://training.github.com/classes/) and help (https://help.github.com/)
• Create account on Amazon Web Services - http://aws.amazon.com/ - creating an account is free, although you
will need to give credit card details
Session 2: Installing an OppiaMobile AWS machine
Time: 2 hours
At the end of this session, participants will be able to:
• Set up an AWS machine with default core version of OppiaMobile server
• Change the default passwords on the AWS machine image
• Set up a static IP address for the machine
• Upgrade the server code from the core OppiaMobile server codebase
• Describe the regular server admin/maintenance tasks
Chapter 8. OppiaMobile Training and Support
OppiaMobile Documentation, Release 0.10.0
• Review of previous session, any questions/queries
• Set up an OppiaMobile AWS machine image (see: Installing on Amazon Web Services)
• Update passwords
• Create an elastic (static) IP address for the machine
• Update the server code from the core OppiaMobile server repository
• Keeping the server up to date (apt-get, backup)
• Configure domain name to point to the server
• Configure the server code to point to clone of core OppiaMobile server
Follow up and preparation for next session
• Download and install Moodle - https://moodle.org
Session 3: Installing and configuring Moodle and OppiaMobile export block
Time: 1 hour
At the end of this session, participants will be able to:
• Install the OppiaMobile Moodle Export Block
• Configure server connection to their OppiaMobile server instance on AWS
• Publish a course from Moodle directly to their OppiaMobile server
• Review of previous session, any questions/queries
• Installing the Moodle block (see: Moodle Block Installation)
• Setting up the server connection to new instance on AWS
• Creating a test course and export
Follow up and preparation for next session
• Create an account on https://mint.splunk.com/
• Create a Google Play Developer account (Google charges for this - currently 25 USD, but it’s a one-off cost for
as many apps as you like)
8.3. Technical Training and Support (course under development)
OppiaMobile Documentation, Release 0.10.0
• Install Android Studio: https://developer.android.com/sdk/index.html
Session 4: Creating own version of OppiaMobile app
Time: 2 hours
At the end of this session, participants will be able to:
• Create, compile and run their own version of the app
• Publish the app on the Google Play Store
• Describe how to set their own app name/logo and default settings
• Review of previous session, any questions/queries
• Clone the OppiaMobile Android app into their own repository
• Set up project in Android Studio
• Make the necessary (required) changes to the code (see: Configuring your own version of the app)
• Review of the optional changes and settings
• Export a signed application package
• Submit to Google Play Store
Follow up and preparation for next session
• Test out the various optional settings in the app
• Add your own logo and name to the app
• Complete Google Play Store app listing
Session 5: Final review and next steps
Time: 1 hour
At the end of this session, participants will be able to:
• Keep their app and server up to date with the core version
• Describe options for hosting multiple instances of OppiaMobile server
• Submit bug/issue reports
• Know where to go to get ongoing help and support
Chapter 8. OppiaMobile Training and Support
OppiaMobile Documentation, Release 0.10.0
• Review of previous session, any questions/queries
• Recap process for updating from the core version (both app and server), and why this is important
• Explain options for hosting multiple instances of server - and pros/cons of each approach
• How/where to submit bugs/issues/feature requests
• Help and support forum
Follow up
• Sign up to OppiaMobile Google Groups - https://groups.google.com/forum/#!forum/oppiamobile
8.3. Technical Training and Support (course under development)
OppiaMobile Documentation, Release 0.10.0
Chapter 8. OppiaMobile Training and Support
Content Adaptation
These pages describe the process and scripts Digital Campus has used to adapt content to be optimised for OppiaMobile.
9.1 OpenWASH Content Adaptation Process
“OpenWASH is a set of innovative learning resources launched in 2016 by The Open University in partnership with World Vision Ethiopia and UNICEF through the ONEWASH PLUS programme, funded by
UK aid from the UK Government. OpenWASH supports the Government of Ethiopia’s One WASH National Programme which aims to radically improve the provision of safe water and sanitation and bring
significant benefits to millions of people.” OpenWASH website
Digital Campus, supported by mPowering Frontline Health Workers, has adapted these Creative Commons licensed
learning resources to be mobile optimised and run on the OppiaMobile learning platform. This document describes
the adaptation process.
9.1.1 1. Importing into a local Moodle
From the OpenLearn site, the resources may be downloaded in a variety of formats, however for this adaptation process
we required the courses in standard Moodle format, so that we could easily collaborate and edit/format the course.
Unfortunately, OpenLearn no longer provides the option to download courses in Moodle backup format, although it
used to. The format most suitable to us to import was the OUXML format - this is an internal OU format used for all
their courses, so can be then exported for print or web.
A script was developed to create a Moodle backup formatted file of all the XML content, plus images, which could
then be restored into a Moodle server.
The script and associated documentation can be found on GitHub:
OppiaMobile Documentation, Release 0.10.0
9.1.2 2. Review of imported content
Once the content had been imported into Moodle, a first export to OppiaMobile was done and the initial quality check
performed. The key areas that we were looking for were:
• consistency in style sheet usage
• formating of info, definition, in-line question and case study boxes
• image importing
As a result of this first check the following updates were made:
• activity icons added, where activities/pages did not have a suitable icon
• formatting of the end-of-session self-assessment questions
• fixes to style sheet formatting where necessary
9.1.3 3. Additional quiz questions
In the original course content, self-assessment questions (SAQs) are provided at the end of each study session. Many
of these questions are unsuitable for automatic marking within the OppiaMobile app - as, for example, they require
the student to write longer text or complete a table of information. These questions have been retained in the mobile
adapted version, but only as HTML pages, rather than as a quiz activity.
Additional self-assessment quiz questions (in Moodle quiz format) have been developed and added to each study
session. These questions are of a more basic type than the original SAQs (eg short answer, multichoice) - however
they allow the student to have their responses marked automatically in the OppiaMobile app.
9.1.4 4. Quality assurance check
Note: Since these courses had already been very well developed by subject experts and copy edited, our QA check
did not include copy editing or validating the correctness of the content/information in these courses.
The courses were exported to OppiaMobile and the content reviewed again within the OppiaMobile app.
We also ran the quiz questions through our quiz checker script - which tests submitting each possible response through
our quiz engine to ensure that the marking and scoring is correct as well as helping with spelling and grammar
9.1.5 5. Creating non-country specific version
The final part of the adaptation was to create a non-country specific version. The original courses have a lot of
Ethiopia specific references, so the idea of removing these is to make it easier to them adapt and re-use the course in
other countries.
Copies of each course were made and a database scan performed to identify the pages which include Ethiopia specific
references. These pages were then updated to provide more general references, the references updated include:
• Ethiopia
• woreda
• kebele
• health extension worker
Chapter 9. Content Adaptation
OppiaMobile Documentation, Release 0.10.0
• health development army
• health promotion worker
• Addis
• Oromo
• Oromia
• tigray
• amhara
• health post
• MoH
• FMoH
• Adama
• korales
• Ministry of Water and Energy
• Mekelle University
• Bahir Dar
• Regional Health Bureau
• Ministry of Works and Urban Development
• MoWE
• Town Water Board
• Hawassa
• Wechale
• birr
• gondar
• Operation and Maintenance Department
• Wuha Agar
• National Fluorosis Mitigation Project
• debo
The script used to scan the content for these terms can be found here: https://github.com/DigitalCampus/
9.1. OpenWASH Content Adaptation Process
OppiaMobile Documentation, Release 0.10.0
9.1.6 6. Final QA
A final export to OppiaMobile of both the Ethiopia specific and non-country specific versions, then reviewed again on
a mobile device.
Chapter 9. Content Adaptation
Getting Help
To get help using OppiaMobile, please post a message on our Google Groups forum at: https://groups.google.com/
OppiaMobile Documentation, Release 0.10.0
Chapter 10. Getting Help
The development of the OppiaMobile platform has been supported with funding from:
11.1 Contributors
• Brightec - video controller
• AndroidPlot - for graphing library
• OkHttp - HTTP library
• Picasso (by SquareUp) - image caching library
• Safdar Ali & Durba Gogia - Hindi translation
• Roman Blanco - Spanish translation
• Marijs Carrin - for testing and development
• Joseba and Adrián (Chaotic Kingdoms) - technical development, performance improvements and bug fixes
OppiaMobile Documentation, Release 0.10.0
• Laila Hussain - Urdu translation
• Lebanese Alternative Learning - Arabic (Lebanese) translation and funding for drag and drop quizzes
Chapter 11. Acknowledgements
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF