Example Pass Version
Example Pass Version
Occupational Specialism:
Digital Production, Design and Development
PASS
Version 1.0
Text here
Introduction
The exemplar materials within this document relate to the Digital Production
Design and Development Occupational Specialism and have been created using
the approved Specimen Assessment Material (SAM). These exemplification
materials are designed to give Providers and students an indication of the
knowledge, skills, and understanding that attest to a threshold Pass grade. Each
task within the GSEM shows the students work at that level for that task at the
threshold of that grade.
Providers can compare the exemplar material against the mark scheme within
the SAM, to give guidance on the standard of knowledge, skills and
understanding that need to be met for Pass.
Activity A(i)
Research
To show and emphasise our design, the following section is a comparison to an
existing fitness website (in this case: https://www.mapmyrun.com/).
Homepage:
From the above, you can see
that the website have a
minimalist style which
refrains from
data/information being
crushed into a small screen
space. The page is split up
into sections where
additional information to
address the advertising and
promotion of the website are
placed. These still
incorporate a minimalist
design, in keeping with the
theme.
The differences are that the main colours that are used, correspond to the colour
of the logo. In our design we have used the same methodology, and have used
colours included in the newly designed logo and the original. Furthermore,
MapMyRun (Under Armour) have used links to an app as well as logging
information on a desktop. Their reasoning will be that it makes it easier for the
user to access the data from their smartphone instead of signing into a desktop
website, however choosing to include the desktop option allows for more
customers who may not have a compatible smartphone to use the service.
1.27s - MapMyRun
970ms – Our Mock Website
This shows that our website will give people a faster response and will allow for
users to access the website quicker than larger corporations such as Under
Armour’s MapMyRun.
Login Page:
Again, a minimalist design has been used in the login page which shows
continuity within the website and provides a professional look for the user.
However, MapMyRun have used a separate page for the user to login whereas, in
our design, the login page is a pop-up which allows for faster access speeds as
the element has already loaded when the user entered the URL. In addition, a
“forgot password” feature has been implemented so that users can access their
accounts even if they don’t remember their password. In our design we have not
included this as many client will be able to have their password reset by users
instead of remotely.
Sign in Page
Dashboard:
In addition, the page includes adverts which can clutter the page and make it feel
unprofessional. On our design, the page doesn’t include any “bad” adverts which
have no remote link to the website’s purpose. Furthermore, in the above
diagram, there were no pop-up adverts that restricted the functionality of the
website.
FITOCRACY COACHING
This website was particularly interesting, you can sign up for free, and provides
you with work out programs and personal trainer you can select depending on
what your goals are. Found it easy to navigate, you can also view other member’s
progress and what problems they have encounter on a live feed. Once have
selected you work out session you can then log your progress as shown below.
Found this to be very valuable.
Activity A (ii)
I have been asked by the owner of ToKa Fitness to develop a digital system that
will:
Target Audience
Designing an App to make it “aesthetically pleasing / state of the art” is not the
first port of call, if it doesn’t appeal to the targeted audience then there is no
point in having a App at all. In the context of this design brief, the App is targeted
at client and user who wish to store and keep track of physical activities.
Developing an easy-to-understand and user-friendly App is a crucial part of any
business as it defines the appropriate target audience – its needs, wants and
expectations of the App.
A further possibility of the use of the App is with smaller personal training groups
as the instructor can monitor progress and possibly motivate a certain group
member to do more activities and set realistic challenges.
Legal Considerations
• Domain Names: Usually they are registered in the name of the designer or
developer and not in the name of the client. It is the client who has paid
for the domain name and therefore the client should be the owner or
registrant.
• Ownership: The creator/designer of the App is by default the holder of the
copyright and therefore the designer is the owner of the App, unless
decided by the client.
• Content: Protection of the designer from the risks associated with clients
giving them information or content that they want to include with the
design when they are not entitled to do so. This may be illegal content or
something that infringes the rights of the 3rd parties.
• Data Protection: It is under UK law that the App notifies the user of what
you intend to use the personal data that you collect for.
• Cookies: Every mobile browser, just like desktop
browsers, has different cookie settings and handle first party and third
party cookies differently. Cookies also exist within apps when a browser is
needed to view certain content or display an ad within an app. However,
the cookies are completely "sandboxed" in apps. There is a requirement
under the amended E-Privacy Directive and the UK.
Regulations to:
• Inform users about cookies and what you are going to use their
information for
• Obtain their consent to the use of the cookies
Currently, gym users who want to track specific details at the ToKa gym are
unable to for their workouts and exercises, often have to do this on paper so
they can track what they have completed during that workout session. However,
this approach means that it’s very difficult to these people to quantifiably track
their results – the client, ToKa Fitness therefore wants an application allowing
users to track and log their activity at the gym. The application would allow users
to enter data such as the exercise, weight, reps and sets the user completes
about each workout, so that the user can track their progress long-term.
The key performance indicators (KPIs) and user acceptance criteria for the
proposed ToKa Fitness offers personal training sessions and advice on fitness
training and healthy living to its customers and would like an App for their
specific requirements. ToKa Fitness specific requirements are that the proposed
solution:
My proposed solution should provide ToKa Fitness with professional and easy to
use system that promotes their business and encourage customers to use it. All
customers would have their own account. ‘Free member’ will have a basic level of
accessibility and ‘Full member’ with a monthly fee for more complex features and
functions.
Usability Features
The design of the above system features a lot that makes it accessible to many
people. It has a simple layout with minimal options, meaning that the
boxes/areas and text for everything in it can be large enough for those who have
sight problems to read. The text displayed would also have to be actual text
rather than images containing text so that it works with text to speech software.
The fonts used should look professional yet easy to read. There is no audio that
must be heard in order for the system to work as intended, as although the alert
will make a sound when triggered, it will also pop up on screen and persist until
dismissed.
There will be use of colours (uncertain about which colours at the current time)
to break apart the sections and make it easier to navigate. Although the colours
would be something to consult my client about, nothing too bright should be
used, so greys, blacks or maybe muted blues and purples would be a good
choice to make sure that everything is broken apart quite nicely but it isn’t too
much that it becomes hard to look at.
The programs basics will function the same as any other so the user has a sense
of familiarity. The cross to close the window will be in the top right corner
(although due to the nature of the program it will still run in the background) and
familiar icons will be used to indicate features such as the dropdown boxes or an
input text box. This will prevent the user from becoming confused.
Member
Private and secure customers area – password protected
Ability to customise some workouts and eating plans
Use of daily food planner with limited food analysis and reports
Use of daily fitness training planner with reports
Access to some fitness training/recipe videos
Links to social media/ blog / forums
Use of daily food planner with food analysis and reports/graph analysis
Use of daily fitness training planner with reports/graph analysis
Access to all fitness training/recipe videos
Link to Social media / Fitness training Videos/ Recipes/ blog / forums
Ability to customise a workout and eating plans
Details analysis of daily foot plan and health plan
Customers would have access to a daily fitness training planner and videos that
have been verified by sports professionals and doctors. It is important that the
videos and planners are safe to use and provide the correct advice and guidance.
The setup of the customised eating plans will also have to be verified by a
nutritionist as they must meet the correct and current nutrition guidance. If the
nutrition guidance is incorrect, the member could get very ill as the result of
following the customised eating plan, and ToKa Fitness could be sued and get a
bad reputation and go out of business.
The App will have to be secure because of the member's privacy and security of
user data to comply with legal requirements such as Data Protection legislation
and food and nutrition regulatory guidelines. Customer details must be secured
by password protection and clear terms and conditions. The interface should be
easy to use and navigate, be accessible across different devices and have
accessibility features for users with sight loss.
User requirements
ToKa Fitness has commissioned my software development company to develop a
digital system. ToKa Fitness offers personal training sessions and advice on
fitness training and healthy living to its customers and would like an App for their
specific requirements.
The target user group are adults, male and females. Due to legal and ethical
nature of Apps, it might be difficult for under-18s to follow the exercise and enter
the correct details and follow the food and recipes correctly. To comply with age
restrictions and guidelines, clear advice will be given to reduce health issues or
injuries.
The customer area will be secure accessed via a password and payment made in
a secure platform. This will comply with legal requirements. The privacy and
security of user data is important for each member to have access to their area
via a secure login.
Each customer will be able to customisable workout and eating plans and
generate a report on their progress for specific periods, and the level of detail of
instructions in a fitness training plan will vary to allow the customer to meet their
identified goal.
All links to external sources will take consideration of Copyright and intellectual
property and Licensing requirements.
Decomposition
The project consists of 6 main features - the ability to add a new workout and
exercises to it, view previously entered data, view progress, edit goals and
update personal details. These 6 comprise the main body of the application, as
identified by my research as the most important features to include. Each will
consist of its own activity and functions, being self-contained. I have not included
optional features I will probably not have time to implement, like custom
exercises or Facebook integration. Each of these 6 main features can be broken
down into their component parts
Validation
In terms of user input, there will be a handful of drop-down menus, and
lots of buttons, which will require no validation as it will be restricted to
correct input.
The input exercises will be limited to the exercises included in the database
initially (although may expand on that and add custom exercises if it is feasible)
and will have stored what type of data each exercise requires, e.g. sets, distance,
weight etc. so that the only types of error possible is the users entering the
wrong values in their data. Add some validation in these inputs to ensure users
don’t enter unreasonable values like lifting 400kg. However, by restricting the
user to pre-entered exercises can at least ensure consistency between
workouts.
Most numerical input can be checked to see if the range is correct, but other
than that it will be very difficult to validate- entering the wrong input will result
in errors in the progress page but allowing users to edit past workouts should
allow them to change any wrong input themselves when they notice wrong
results in the progress page.
Activity B
Visual/Interface Designs
User Interface
HOME PAGE
GOALS PAGE
Usability Features
My main criteria for usability of design is that each feature is clearly signposted
and can be completed with a limited amount of clicks to ensure the system is
efficient.
Using a standard design for the menu page means users will instinctively know
where to go to find features they would like to use, and consistency of the design
of each page (i.e. same style of inputs) will allow users to very quickly understand
how each activity functions. Each activity has a clear heading and access to the
menu page so users know they can return to any point in the application quickly
and easily.
The design of the application has been done with the intention of having a
designated activity for almost every task, so that each page can be kept as simply
as possible and it is easy to signpost the user to each feature. This means that
users can access each feature through the menu system and as a result reduces
the clicks needed to access each feature and improves time efficiency for them to
input their data after each workout – this satisfies my success criteria. The
consistency and limited objects on each page means the user will always know
how to navigate the application and should the application should have excellent
visual clarity, if you limit the application to a handful of colours and use
consistent fonts and font sizes. Having links to essential pages also on the home
page is good practice in terms of usability. Keeping a menu button on the top bar
of every activity will always allow users to get back to where they were if so
needed.
Additionally, as the colours used in XML elements in Android Studio are defined
in a values file, it’s easy to define the few colours used in a colour scheme there
and have the application use them automatically. This makes the application
easier to use as each activity is consistent.
As android applications are event-driven, i.e. driven by the users actions rather
than the results of previous code, the algorithms given below are used when an
application is triggered to create, or when a button is pressed, for example. Not
detailed below are the parts of the application which handle this, such as setting
listeners for the users actions- these trigger the algorithms given below.
These are the algorithms associated with add new workout activity.
This procedure is ran on launch of the activity- it builds the GUI of the page and
defines its behaviours. It will create each GUI object such as text or buttons and
defines which procedures buttons call on click. It also calls the displayInput
procedure which displays any exercises and corresponding input which has been
sent by add new exercise activity. This is a separate procedure as it may be called
several times over the life of the activity.
The displayInput procedure displays any exercises which have been selected as
part of the exercise. If the activity is launched from the menu, then none is
displayed. If the activity is launched from the add new exercise activity, it will
display data passed by that activity and any saved while the user is selecting this
input by looping through the data and creating text objects and button objects
for each exercise input.
When the user wants to add more exercises to their workout, they can press the
add button, which calls this procedure on click. It stores any previously input data
until the user navigates back to this page, closes the activity and launches add
new exercise activity so the user can input more data.
If the user decides not to input this data, they can press the cancel button, calling
this procedure. It deletes all saved input data, closes the activity and navigates to
the home page.
This procedure is also optional- if the user wants to auto-input data from their
last workout, they can press on the “Day” text and it will call this procedure,
which displays a calendar and calls the displayInput procedure if the user does
select a day.
Each displayed activity will have a delete button next to it to aid usability of the
application. The delete button calls this function with its own ID, which then
deletes all objects associated with it (i.e. the exerciseName text object, statistics)
and deletes the data from the internal array of inputs. This allows users to delete
one input exercise without having to delete and re-input everything else.
The save procedure comprises of the main bulk of the code for this activity. When
the user has finished inputting their data, they press the save button which calls
this procedure. The procedure must then create a new workout in the workouts
table, then get the ID of the new record to be used later. Then it loops, so that it
can check in the exercise bank which statistics are applicable to that exercise,
stores the relevant attribute names, and gets the exercise ID, so that for every set
of data in the array, the procedure will add a new record to the exercises table
entering data into the relevant statistics and null values into the others. Then the
procedure deletes any stored data, closes the activity and reopens the home page.
These are the activities associated with add new exercise activity.
The build procedure is called on launch of the activity, to build the UI. It creates the
objects needed, then calls the displayExercises procedure to display all exercises.
The displayExercises procedure is also called from the search bar or drop down
menu if the user inputs any preferences on the data they want displayed.
This procedure is called on click of the done button, and sends the user back to
add new workout activity, passing all the input data to it.
users may want to add to their workout, depending on any previous input. If it’s
called on launch of the activity, all exercises are displayed. If it’s called from the
search bar or drop down menu then the SQL is modified to query the exercises
related to the users search and display the relevant exercises. The exercises are
stored in the exercise variable then iterated through to create all the relevant
text objects.
The add button gets all the input data from the fields of that exercise, and adds it
as an array to the data variable, which will store all input data while this activity is
running, and be passed back to the add new workout activity when the done
button is pressed.
Once all the exercises have been displayed, they will need to expand to show
input boxes for the relevant statistics so that the user can input their workout
stats. The procedure gets the data for that exercise from the exercise bank and
displays an input box for each relevant stat. It also create a button ADD for when
the user wants to save this data.
Edit Goal
This procedure is called on launch of the activity- it creates text objects for the
titles, and creates an array of the names of the goals. Then it connects to the
DBMS, gets the current goals set, and iterates through the goals to create the text
and input objects. It also creates the buttons at the bottom of the page to save or
cancel the input.
The save procedure is called on click of the save button and gets all the data
from the input boxes, updates the personal details table to include this
information and exits the activity.
This procedure just exits the application- it exists mostly to aid usability.
Validation
In terms of user input, there will be a handful of drop-down menus, and lots of
buttons, which will require no validation as it will be restricted to correct input.
The input exercises will be limited to the exercises to include database initially
and stored what type of data each exercise requires, e.g. sets, distance, weight
etc. so that the only types of error possible is the users entering the wrong values
in their data. Add some validation to inputs to ensure users don’t enter
unreasonable values like lifting 400kg. However, by restricting the user to pre-
entered can ensure consistency between workouts.
Most numerical input can be checked to see if the range is correct, but other than
that it will be very difficult to validate- entering the wrong input will result in
errors in the progress page but allowing users to edit past workouts should allow
them to change any wrong input themselves when they notice wrong results in
the progress page.
The best enforcements of validation that I can make to ensure incorrect data will
not crash the application, is to include a presence check on every input box and a
type check on every database insert
Databases
Android studio allows for the implementation of data storage using SQLite so
this will be my primary method of storing all the users’ data. As I have restricted
the scope of the project to make it manageable, I will store all the users’ data on
their device and therefore do not need to store and query many users’ worth of
data. The attributes I need to store for each user are as follows:
These are the entities I will be including in my database. 2 are simple stand-
alone tables, while exercise bank and completed workouts both have a one-to-
many relationship with completed exercises. This is because exercise bank and
completed workouts would have a many-to-many relationship if this entity
were omitted.
Personal Details
These are the basic details the user enters as part of their setup. They can be
used to calculate stats such as calories burned and the user can update weight,
bodyfat etc. as part of their progress to be measured. Weight and bodyfat are
not stored in this table- in order to keep a record of previous measurements to
be used for calculating progress, I will need to keep many values so the repeat
data will be stored in a separate database exclusively for these values.
Attribute Data type and restrictions
Name String (32 char max)
Height (optional) Integer/float. 0<height<250 cm
Gender (optional) Char (M/F/N) or null
Date of birth (optional) Date or null. Must be younger than 100, older
than 10.
Goal weight (optional) Float or null 30<weight<250.
Goal bodyfat (optional) Float or null. Restrict to safe values,
Goal weight lifted (optional) 2d array of float and body part or null
Goal workouts per week Integer
Exercise Bank
This will be set up by me so there will be no need for any validation of this
database. Upload a sample set of exercises into it as part of my development
process but can be expanded to include hundreds and potentially allow the
users to put their own custom exercises in it too (which would need validation).
This is all the statistics that will be tracking, although the design of the database
should easily allow me to add more if my clients request any others,
Completed Exercises
There will be a one-to-many relationship between the completed workout
table and completed exercise table and between the exercise bank and
completed exercise table. Each workout is made up of several exercises of this
table. The presence of data in each attribute of this table is determined by the
Boolean values in the relevant columns of the exercise bank table.
If the clients decide that they want other data tracked than what has been
designed, it will be easy to implement in the database. For example, if they
want to track another type of stat for an exercise, it can be entered as an
attribute in the exercise bank table with a Boolean value dictating when it is
used and a corresponding attribute added to this table. This should not affect
the normalisation of the database.
Expansion Of Project
If need to expand the project and have all the users’ data stored on an external
server, may have to modify these databases to allow for keeping each users’ data
separate. As this is not within the scope of this project, also designed the
database with one user per device in mind.
Querying Database
Intend to query the database for several purposes- will need to get current
details in order to display to the user their previously entered personal details
and goals. Also need to get exercises from the exercise table to display to the
user when adding their exercises to a workout and check if each attribute is
relevant to that exercise.
Need to query the database to get data to calculate the users’ progress. If, for
example, by calculating their body fat change, will need to get the measurement
and date of each measurement from the progress updates table, and either put
each value into a graph or other visualisation, or calculate the total change and
percentage change from the first and last pieces of data
Testing
Approach to testing:
To test my solution white box testing (where I test the internal structure of the
App) and black box testing (where I only test the inputs and outputs).
As this activity was rigorously tested during development, no issues in the post-
iteration testing.
Again, as this activity was rigorously tested during development, there are no
more issues with the program.
Stakeholder Feedback
I asked a potential user a few questions after they had some time to use the
application.
Yes- the swipe menu is very similar to most applications so you don’t have to
learn something different to use the app. And everything is the same sort of
colour scheme so it’s obvious where buttons and input boxes are.
Q3) Are there any other comments you have about the application at this stage?
I’m sure I’ve used apps before which can display a calendar to let you
choose a date- that makes it much easier. Would it be possible to change
that?
This survey is encouraging- all the completed parts of the application are working
as intended and no unexpected errors have escaped testing. The issue of missing
parts of the application isn’t a problem as these will be developed in the next
iteration.
As the user requirements are clear and, due to legal and ethical implications of
using the identified assets, all of the images are to be sourced from free imaging
providers or providers that allow use for non-commercial: “License: Non-
commercial Use”. Some of these providers require you to set up an account to
download the images and some ask you to reference the source of the image.
Care was taken when selecting the images to use due to the legal and ethical
implications of the assets.
Great case was taken when selecting the external links to the health and fitness
and food external links. All of the recipes were from a reputable source and
promoted healthy eating and most identified the nutritional value of the meal.
They were easy to follow with clear images of the prepared dishes.
The health and exercise video and information links were sponsored by medial
and personal trainers and supply App help and guidance as the customers will
be using these videos unsupervised by health and medical experts. All of the
links hosted fitness videos of a very professional quality and level.
From the research of possible code snippets, the only code that I am going to
modify is “chat room and blog example code”.
https://imgbin.com/png/wfLgfRPc/computer- This is my
icons-mobile-phones-png option for
“no access
to
member’s
area”.
Users may
find the
other
option
confusing
and it has
too many
colours.
https://imgbin.com/png/Jm6mwH7T/a-logo- Decided to
png use this
icon as it’s
free for
non-
commercial
use as the
other
option
needs an
extended
license. It
also stands
out.
https://www.flaticon.com/free- Used this
icon/facebook-logo-button_69407 social
media logo
as users
will be able
to identify
it quickly.
https://www.stickpng.com/img/icons-logos- Used this
kemojis/tech-companies/whatsApp-logo social
media logo
as users
will be able
to identify
it quickly.
https://www.stickpng.com/img/icons-logos- Used this
emojis/tech-companies/twitter-logo social
media logo
as users
will be able
to identify
it quickly.
https://www.stickpng.com/fr/img/icones- Used this
logos-emojis/societes-de-technologie/logo- social
youtube-play media logo
as users
will be able
to identify
it quickly.
https://www.flaticon.com/free- Used this
icon/instagram-logo_69366 social
media logo
as users
will be able
to identify
it quickly.
<a href="https://www.freepik.com/free-photos-vectors/logo">
Blogs
Test Strategies
works as designed once built. This prevent larger errors occurring later. This will
involve testing all the buttons work as planned, that all input is processed
correctly, and all output is correct in each activity. Some activities will involve
rigorous testing including the use of correct, incorrect and extreme input. This
will also include destructive testing.
For example, the test plan for the “Progress Updates” activity will be something
like this:
Test Test description Expected result Actual result Successful?
Number
1 Add a more recent Most recent update
update is
displayed on creation
Development
Throughout the development of the application, at the end of the programming
of each iteration, I will distribute to my client a prototype of the application, once
I have completed my own testing. The client will be able to tell me if they have
come across any other issues in the prototype, and if they feel the application so
far is successful and meeting the solution requirements.
Other than the import statements, the rest of the class is shown. The method
onBackPressed() overrides the standard method from the Android Studio
libraries, to allow the user to use their back button to close the navigation
drawer if it’s open. If it’s not, then super.onBackPressed() calls the method from
the superclass to undo the most recent action as expected.
The navigation menu when drawn looks like this. It’s called from the activity by a
3 lines symbol in the top left of any activity and swipes open and closed as
required. This is all handled by the NavigationView class. On the menu, 6
activities have been created according to the design of the application, which are
currently empty. When the user clicks on an option, the app navigates to their
chosen activity. As these are only click buttons, there is no need to include any
kind of input validation at this stage.
In the Java class of each activity, an onCreate() function exists which is executed
on launch of the activity. In here, the onCreate() function of the superclass is
called, the XML file defining the layout is declared as activity home, and the
toolbar is created (the bar at the top of the activity containing the navigation
drawer button.
The next section of the method creates a navigation drawer, defines the creation
of the button which opens and closes the drawer, and creates a listener which
waits for the user to select an item from this drawer and calls my function
onNavigationItemSelected() in the BaseNavDrawer class to implement its
behaviour.
These lines of code are included in the onCreate() method in each activity’s
corresponding class so that each activity can include the same navigation drawer.
This code can’t be extracted as the onCreate() method must be included in each
activity in order for Android Studio to compile the activities correctly.
The set up for the database system is more complicated- For the project chosen to
use Android Studio’s Room Persistence Library to interface between the
application and the SQLite used with the OS. In the Room library, a Java class and
corresponding interface have to be created for each entity, and a class to define
the overarching database structure. All these classes have been placed in a
database package to make the file structure of my project easier to manage.
The class which manages the database system is named AppDatabase. The Room
library makes extensive use of Java annotations, so this class is annotated with
@Database, allowing me to declare the entities involved as attributes, the version
number, and the default backup option. The rest of the code above creates the
DAOs (Data Access Objects) to be used in accessing data from each entity.
This is the constructor for the AppDatabase class, i.e. is called when an
AppDatabase object is created inside an activity. It checks first if the database
already exists, then exits if it does. Else, the database is created, and the callback
created alongside it is executed. The callback calls the run() method defined inside
it which pre-populates the database with the data provided (at the moment this is
only 5 sample exercises although I will expand it later on). The run() method exists
inside a Runnable object as part of an Executor object – I will talk about this in
detail later on.
On building the database, there were some problems with updating the schema
when it changed the code in the AppDatabase class. As the database was already
created when adding new entities, the correct way to update a database when
sending application updates is to perform a database migration- this is a mapping
of the old database onto the new database. However, it’s complicated to
implement correctly, and during development, it’s significantly easier to delete the
application and all database data, and reinstall with the new and updated
database structure. This would obviously NOT be done when updating the
application on a real user’s phone, as they would lose all their data.
Trying to use an updated database structure without erasing all the previous
data returns several error messages, including “Looks like you've changed
schema but forgot to update the version number”. This error can be fixed by
incrementing the version number, but that results in a new error.
“java.lang.IllegalStateException: A migration from 1 to 2 is necessary. Please
provide a Migration in the builder”. Android Studio won’t allow database
schema to be updated without a migration path specified so that data isn’t
accidentally lost or corrupted. The best way around this during development is
simply to erase the database and reinstall it. The final part of the class creates a
Above is the content of the Java class which defines the structure of the
completed exercises entity. Each entity I have created has the same attributes as
in the design of the application. The class is declared with the entity annotation,
which is also where the entity-entity relationships are declared. Below that, the
primary key is defined, and set to auto-generate as a unique integer, then each
column is defined with its name and variable type. Below the column declaration
is all the getters and setters required.
The classes and corresponding interfaces for each entity have the same or similar
format, with a few extra methods as shown below.
Inside the declaration of the Exercise Bank entity is this extra code. I have created
a constructor to set all the attributes of the object at once, just to reduce the lines
of code necessary, and a method called populateData() which returns as an
array of objects of type ExerciseBank, 5 sample records for the database. The
method is used in the AppDatabase class to pre-populate the database.
The other problem I have run into during development with the Room
Persistence Library is to do with threading. As database operations can be
computationally time-consuming and therefore make an application become
laggy, the Room Persistence Library doesn’t allow database operations to occur
on the main thread. When I first tried to run insertAll (), I encountered an error-
“Caused by: java.lang.IllegalStateException: Cannot access database on the
main thread since it may potentially lock the UI for a long periods of time.”
This require managing other threads for these operations to be ran on.
This callback is created during the build of the database, as shown above in the
This strategy of defining Runnable and Executors inside of their calls is useful as
it restricts their domain to where they are used, but it can get messy and difficult
to understand the code involved. This particular Runnable is only to be used
once to pre-populate.
The alternative to defining an Executor within its call, is to define the Runnable in
a separate class. This means that the same Runnable can be used many times
from many points in the application without having to redefine and recompile
the class. Here, the constructor defines the class variables as the data to be
added to the database, then the run () method inserts the data from the
Runnable declaration into the User database.
Testing
The project has been extensively tested during first iteration – the navigation
menu and the database. In this series of testing, tested each activity launches
each other activity.
launches launches
14 Navigate to edit goals Edit goals Edit goals Yes
activity activity activity
launches launches
15 Navigate to personal Personal details Personal details Yes
details activity activity activity
launches launches
In the next iteration of development, I have decided to build the edit goals activity
and the personal details activity, as they are both self-contained, and deal
exclusively with the entry and maintaining of input data in database entities.
I have started with building the basic structure of the UI as per my design for
both activities. Below is shown the UI as displayed on my phone, not the android
studio virtual machine- it has slightly different dimensions and so the input boxes
will need to be readjusted based on the actual dimensions instead of the VM
dimensions.
Test
In each input box, the current value is displayed- however, when this is removed,
a hint is shown as to what to enter. All the activities built in this iteration include
only text objects, buttons and input objects on their GUI.
Added this clause in the validation methods- it checks every character input for
the users name that it is in fact a letter and not a number or symbol such as ‘!’.
The personal details activity begins by declaring the class variables to be used,
and creating the on click listeners- this is the code which will be executed when
the on-screen buttons are clicked. When the save button is clicked, addtoDb() is
called, and when the cancel button is clicked, cancel() is called.
The on create method for this activity is shown above. All the code presented
(defining the menu objects and initialising the database), and then the other GUI
objects are connected to the code by means of a unique ID declared within the
XML. Each GUI object (text, buttons, input, etc) has be connected to the code this
way in order to change anything during the execution of the application. The next
section of code calls the getDetails() method. This method returns the most
recent update stored in the database, so the on create method can use this
information to display the most recent data in the input boxes. This means that
the user can see what they last entered as an update, and promotes usability of
the application as users won’t enter duplicate data.
The last part of the on create method gets the current date from a Calendar
object, and sets the input boxes relevant to the current date. This should reduce
clicks required by the user, as mostly updates should be entered on the day
measured, and will at least be entered within a few days.
This is the getDetails () method- it’s called from the on create method as shown
above, and returns the users most recent update in a ProgressUpdates object. In
order to retrieve this data from the database, an Executor is created to execute
the code in a non-GUI thread, but this time it’s running a Callable instead of a
Runnable. The only distinction is that a Callable returns a value, in this case, a
ProgressUpdates object. The returned value is stored in a future object, and
retrieved in a try/except block, so that the program won’t crash if the database
execution takes all ongoing time and no data is as of yet stored in the future
object. Once this code has executed, the most recent update is returned to the
on create method.
This is the addtoDb() method called when the save button is clicked. It creates a
ProgressUpdates object to store the input data in, then validates the input data.
If the code finds that the user has failed to enter a value in one of the boxes, the
presence check will fail, an error message will be displayed and the method will
escape. The values are retrieved from the input objects, and the validate function
is called, which conducts range and other checks on the input data. If the data is
valid, the error message is made invisible, and the addUpdate() method is called
with the new ProgressUpdates as a parameter. Else, an error message is
displayed and the method escapes. All of this ensures that incomplete records
aren’t added to the database which will cause errors further down the line, and
ensures that the user doesn’t accidentally enter incorrect data into the database.
The addUpdate method again uses an Executor with a Runnable to insert the
validated input data into the progress updates entity, and returns the user to the
home page.
This is the cancel and presence check methods. The cancel method is called by
the cancel buttons on click listener, and resets all the input values to null. This
will cause the hint in the XML to be displayed in the input box instead.
The presence check uses the isEmpty () method on an input box to determine if
there is a value present, and returns the validity of the data.
The last method of this activity is the validation. It receives the users input data
as parameters, and conducts range checks on the body fat and bodyweight, and
checks all dates are valid, e.g. not February 30th or June 31st. This returns the
validity of the data to the addtoDb () method in order to decide whether the
code should proceed in adding the data to the database.
The next solution to solve this, was to have the home activity test for the
existence of the database, and again, pre-populate the Progress Updates entity
with invalid data, and the Exercise Bank with some sample exercises. Appeared
to work on my VM, but couldn’t remove the invalid data successfully, and testing
for the existence of the database didn’t work on my phone. Maybe due to some
distinction in the compilation of the application between different devices as my
VM is a Google Nexus and my phone a Samsung.
The eventual solution to all these issues was the creation of activity outside of my
initial designs, which allows the user to pre-populate the database with their
details on install. The code ran on the home activity is shown below, the first
code block being part of the on create method.
Here, the on create method creates a shared preference object, firstRun, set to
true on creation of the variable. This variable is static across the whole
application and can be changed in any activity. If firstRun is true, the goToEntry
method is called which takes the user to an activity called InitialEntry. This is
where they can enter their personal details and first progress update. In the
InitialEntry activity, once the user’s personal details have been added, this is
changed to false and never used again.
This code has been inserted into the on create method of the home activity. The
activity is triggered by this SharedPreference, which is static across all activities.
It’s set to true on creation of the preference, and then later set to false within
InitialEntry on completion of all the input data. This variable remains as false
across all activities from then, and so the InitialEntry activity is never retriggered.
The class begins by initialising all the class variables required to hold the input
boxes, in EditText objects, and the buttons and database. Then, the listener for
the save button is defined as calling the addtoDb () method and then the
goHome () method which returns the user to the home page.
The on create method is shown above for the InitialEntry activity. The first block
of code initialises the toolbar and calls the super class on create method, the
same as every other activity. The save button variable is linked to the save
button in XML through the findViewById function, and the on click listener
defined as the one previously shown. Then, all the input boxes in the XML are
connected to their corresponding variables in the code. Note that the code for
the navigation bar isn’t included in this class as it should not be possible to
navigate away from the activity without entering the required data, and
shouldn’t be possible to re-enter the activity on completion.
The goHome() method is called from the save buttons listener, after all the data
entry has been complete. It just directs the user away from this activity so they
can now use the rest of the application as intended.
The first part of the addtoDb() method initialises a new object of types Progress
Update and Users in preparation for the data. Then a presence check is
conducted on all the input boxes- if the user has failed to enter a value in any
fields, the code will display an error message and stop processing the data. The
next block of code collects the input data into variables.
The next part of the addtoDb() method gets the current date to be used in the
update object. Then, it conducts a range check on all the input values, and if a
value is out of a set range, the code displays another error message and
discontinues the method. A series of other checks are conducted on dates and
gender, and then if the input data passes all the checks, the attributes of the
objects created earlier are set to the input data, and addUpdate() is called.
The addUpdate() method is the final part of adding the data to the database-
once it has been validated and set as attributes in entity objects in the previous
method, addUpdate creates an executor and inserts the input data into the
Progress Updates entity and Users entity. Additionally, as a solution to the pre-
population error I had earlier, the pre-population of possible exercises is
completed here. Then, the SharedPreference() which triggers the InitialEntry
activity is set to false, so that once complete, this activity is never called again.
The presenceCheck () takes in the Edit Text object linked the input boxes on the
UI as a parameter, and uses the isEmpty () method to conduct a presence check.
It returns the result of the check.
The final part of the InitialEntry activity is the method involved in validation- the
angeCheck() method compares the parameters with values I have set as
acceptable, and returns the result of the check- true if the data is valid and false if
not. The otherChecks() method conducts the last few checks required- ensuring
that only M or F is entered in the gender box and that invalid dates such as 31st
June are not entered. Again, the result of the validation is returned to the method
call. As demonstrated above, for each activity, I will need to test the
successfulness of each button under different circumstances/input data, and I
will also need to conduct presence and range/value checks on most input boxes
which allow the user to type.
Testing
I have extensively tested the elements built in this first iteration – the navigation
menu and the database. In this series of testing, I have tested that each activity
launches each other activity, which is about 39 tests in total, so I have only
detailed one of each type below.
launches launches
12 Navigate to view View past View past Yes
past workouts workouts workouts
activity activity activity
launches launches
13 Navigate to see progress See progress See progress Yes
activity activity launches activity launches
14 Navigate to edit goals Edit goals Edit goals Yes
activity activity launches activity launches
15 Navigate to personal Personal details Personal details Yes
details activity activity launches activity launches
Test
One major problem encountered during the development of this activity, was
issues with the delete button. Originally, tried to delete first the items in the
completed workouts table, then in the completed exercises table, but due to the
enforcement of referential integrity, this was preventing any items being deleted.
This was fixed by reordering the statements as in the code shown above.
The UI is shown above, as displayed when an exercise has been selected. The
add new exercise activity is accessed through the add button on the New
Workout activity, and not the navigation menu like the other activities
The class begins with its class variables and the on click listeners for the done
and add buttons which call the done() and add() methods respectively.
As, I have not yet built parts of the application to display data from my databases
and not yet been able to test that the data entry to see if it’s working. However,
the application now runs without crashing when attempting to complete
database tasks such as its creation with the wrong version number, or
attempting to run code on the main thread so I have assumed that the use of
Executors to manage threads has been correctly implemented. More testing will
be done in later iterations on the database.
As the more testing was done managed to corresponding errors during the
development of the code (such as updating the schema of the database resulting
in a version number error), the use of the whole application together has not
resulted in new errors in this iteration.
The test data shows that the current account system is very robust and only has
minor problems that do not affect its function and security (phone number can
be changed to have incorrect datatype in profile page).
The test data shows that the system functions correctly and is quite robust; this
is shown by the lack of problems when inputting the erroneous data ‘555’ (via
‘inspect element’ rather than selecting the available options).
The final product must also be compatible with various devices, such as
smartphones or tablets. This criterion is at least partially met: Although the App
functions perfectly and is easy to use on a typical smartphone or desktop, the
App might not be as appealing due to possible lack of testing on many different
screen sizes e.g. holding a phone or small tablets sideways will make the App
functional but ugly (due to thick scrollbars). Also, not many browsers were used
to test the App (only Chrome, Edge and Firefox), so the App may not work
properly in some browsers.
To fully meet this criterion, I could create a subscription menu only available to
regular users in the future. This was not done in this prototype because I did not
have enough time and the scope/ambition of my client’s business was
misunderstood (couldn’t host a file server, so the subscription system was not
worth implementing).
According to some testers, the App was easy to use/navigate and aesthetically
pleasing; this suggests that the App had a low amount of clutter. These 2 points
show that the App fully meets another success criterion, where the App’s layout
should be simple and easy to navigate and is not confusing. However, I believe
that the App has too much text compared to images and other media.
Overall the App performed well the App navigation performed well, and it was
easy to use.
Services and functions to develop further are the content of the email
confirmation, will include information about full membership and the terms and
conditions. Some of the testers found that the type of exercise from the drop-
down and quick list did not have many options. I will add further options to the
exercise list. This will ensure that users have the ability to customizable workout
and eating plans to provide a daily progress report on fitness training /food &
calorie daily intake/ weight progress/sleep/water.
They also reported that linking to other technologies was not a stable option.
Some technologies linked and the data was imported and calculated in the App
but not all technologies. This needs to be investigated further and help files or
links added to the App.
The search facilities for recipes were not as effective, the search function worked,
but the search results need to be more specific with the user’s keyword search.
One tested did not like the sound effects when entering data, the other users
had no objection, so this facility will remain as it confirms when data has been
inputted into the App. Testers were able to download social media Apps. One
tester suggested that a link to ToKa Fitness Facebook page would also help.
Task 3: Evaluation
Post-development Testing
Beta Testing
Client 1: Functionality: 8/10
Usability: 9/10
Robustness: 6/10
Other Comments: I found the application easy to use and because I’m not a
significant fitness buff the fact that the interface is much simpler than other
applications didn’t put me off like I usually am. I would continue using it in my
real life if I could add my exercises to it- the sample bank was tiny. All I need is
somewhere to see what I’ve done before, and this application provides it well.
Other Comments: Although the application was easy to use, I found that it didn’t
fulfil my needs. I can write down what I’m doing on a piece of paper or any other
app, but what I was hoping for was more of a measure of progress in terms of
strength- I would like to see some means of how much more weight I’m lifting
over time by body part and perhaps a graph of changes in body fat. This
application makes the bare bones of the features easy to use but wouldn’t
persuade me to change to using it fulltime.
Other Comments: My main issue with the application is that over a long period, it
would be impossible to see past data. I can’t see myself scrolling back through
hundreds of workouts to see the details of them- I need some searching feature
for both exercises and workouts to make the application more natural to use for
me on the whole. Other than that though I did find that it fulfils all the
requirements I had for it- I can input all of my data pretty quickly, and it allows
me to do everything that I need to do.
Other Comments: I did find that the application let me do everything it was built
to do quickly and without errors. However, the optional functionality missing
(such as searching for exercises, modifying workouts and graphs of progress)
would make a substantial difference to how satisfied I would’ve been with the
end-product.
On the whole, my client’s results are encouraging- most of the problems they’ve
found are due to previously identified issues or because some of the optional
features haven’t been developed yet. No major technical problems have
uncovered, so I have no more bugs or errors to report and fix, which I would say
is some success. Additionally, the clients almost all tend to conclude that the
application is, in fact, easy to use, and works robustly for the functionality it
provides, and so could be a partial success at least.
Solution Requirements
Key features:
Additional functionality
As shown in the above tables, all of the key requirements for functionality
originally received from my clients have been met. This means that the
application can successfully and reliably do all of the things it MUST do, however
Success Criteria
The above table contains the success criteria identified in the analysis of the
project and declares whether each criteria is met and where. All of the success
criteria have been met, with the exception of 6 which suffers from the same
problems as the clients feedback earlier- some lacking additional functionality
means the users can’t add custom exercises currently.
Further Development
As previously identified by beta testing and review of the success criteria and
requirements, the key features wrong or missing from the application as it is are
as follows:
All of these are things which can be developed and integrated into the
application in the future in order to improve it and ensure it meets all the client’s
requirements and makes it easier to use. Other features which could be
developed in future include integrating a social feature- this would allow users to
share their progress or workouts on media like Facebook or Twitter directly, or
allow users to interact with each other within the app, seeing their friend’s
workouts perhaps for inspiration, motivation and accountability. Before social
integration could be developed, the application would have to move towards a
server based login system, as opposed to the use of local storage, so the
database interactions would have to be redesigned (although I deliberately
designed the database to support multiple users in the event that I did move
towards a server based option during development).
workout and input only the sets/reps/date etc. It would make it much easier and
faster to add details of a pre-created workout or previously input workout,
perhaps by creating them in an additional page or choosing from workouts done
on different dates. Auto-generating workouts and a workout plan is a feature
included in many published applications, although I’m unsure of how popular it
is- my application intended not to teach clients how to work out but to facilitate
them in their plans, and so although auto-generated workouts could give clients
some inspiration, auto-generated workout plans perhaps are not the best
approach.
Conclusion
On the whole, I would consider the final product to be at least a partial success. It
implements every key requirement correctly and without any unforeseen bugs,
and the client’s beta testing has resulted in excellent scores for usability and
robustness. There is definitely room for improvements in terms of adding
additional functionality, as some clients have realised that they need a few more
features than originally thought to make the application viable for day to day
use, and very few types of progress have been implemented so far into the
application. Both are things outlined to be completed in any further
development. The application meets all its success criteria at least partially, but
has some limitations in usability and functionality Changes required:
The App is suitable for the target customer group are adults, males and females
and complies with age restrictions and guidelines clear advice will be given to
reduce health issues or injuries and complies with the industry’s legal and ethical
requirements. The customer area is secured and accessed via password but no
payment option however this complies partly with legal requirements. The
privacy and security of customer data is important each member will have access
to their area via secure login. This will ensure that ToKa Fitness is perceived as a
reputable company and encourage existing customers who have access to digital
devices to use more of the services provided by ToKa Fitness. Hopefully to also
encourage new customers to use the App and services.
The App can be accessed via mobile devices and a computer and compatibility
across different devices Android and iOS, as requested providing the customer
with further options and flexibility of use especially accessibility the features for
customers with sight loss. During the testing process, it was identified that the
‘My plan page ‘was the summary of food and fitness training reports were
displayed. The remaining calorie and fitness training targets were displayed in
coloured text. Demonstrate that no input is required. This is a summary of daily
calculations.
The candidate has provided limited definitions of the functional and non-
functional requirements and have written them into the user needs. The
candidate has not mentioned potential risks and constraints concerning the
development of the product.
Activity B
The proposed designs are fit for purpose. The candidate has demonstrated the
aim of each object and that does not diminish other information which is
relevant to the product.
The candidate has shown some design considerations, placing objects on the
screen appropriately but with little information on layout and use of white space,
elements, or page specification. There is also no conventions or hierarchy
navigation map, illustrating the direction the user would take or be able to
navigate around the app.
Algorithm
In the algorithms section, the candidate is using pseudocode. The necessary
process of decomposition has been used and explanations and clear. The
algorithms demonstrate some understanding, and the candidate has explained
the inputs, process and outputs. Each step is defined, uses sensible names for
variables, and indention has been provided although inconsistencies still exist.
Data requirements
The candidate has created a database with more than one table, then
normalisation should be included. The ERD is present but incorrect in the
relation. The candidate has provided variables with data types and explanation
which are appropriate. Data types are appropriate and normal conventions have
been applied.
Test strategy
In the table, the candidate has mentioned the two main types of testing Blackbox
and Whitebox testing. They have indicated how they plan to check the primary
and relevant data entry points.
The design consistently communicates the work, techniques, methods, and the
formats are correct. The developer has shown excellent progression from the
abstraction model to the algorithms.
The prototype has been planned and meets some of the criteria. Techniques
and technical skills are appropriate and the use of API for the data table shows
this. The structure is modular, and code is well organised though it does lack
comments. Indentation used throughout the use of local variables and global
variables. It is a basic interface which is consistent, though it lacks clarity on-page
elements such as fonts and colours.
The candidate has provided some feedback from testers. The questionnaire and
observations feedback and grading are appropriate. There have been some
changes made based on user experience.
The assets used are appropriate for this product and the candidate has
considered legal aspects.
The candidate has provided evaluation that matches the needs of the client. They
haven’t clearly shown how they meet the functional and non-functional
requirements.
Throughout the project, the quality of communication has been appropriate and
somewhat technical in areas. They have discussed techniques and methods used
and appropriate for the intended audience.