Literature Survey

  Title - Mobile fitness app

Name -Vishal Bhojwani, Saurabh Kumar Gautam

  Tools/technology/languages used in the implementation of the project

The platform that the application runs on it is Android. the app was developed in a
native programming language (Java). Although developing in native programming
language is more challenging, it also ensures high performance and ultimate user
experience.
 Android Studio
Android Studio is the official Integrated Development Environment (IDE) for Android app
development. Based on the powerful code editor and developer tools from IntelliJ IDEA ,
Android Studio offers even more features that enhance your productivity when building
Android apps, such as:

 A flexible Gradle-based build system

 A fast and feature-rich emulator
 A unified environment where you can develop for all Android devices
 Apply Changes to push code and resource changes to your running app without
restarting your app
 Code templates and GitHub integration to help you build common app features and
import sample code
 Extensive testing tools and frameworks
 Lint tools to catch performance, usability, version compatibility, and other problems
 C++ and NDK support
 Built-in support for Google Cloud Platform, making it easy to integrate Google Cloud
Messaging and App Engine

 Architecture
Every project should use an architecture so that the code can be organized better. The
choice of an architecture is not specific and depends on the application’s requirements. The
benefits of working with an architecture pattern are
Simplicity: The debugging is easier, because the role of each component is specific. So, each
class does not contain a big number of functions that are difficult to keep track of.
Testability: Unit tests are easier to write because the logic is simpler.
 Maintenance: As we mentioned it is easier to keep track of the functions. Thus, the easier
to keep track, the easier to maintain and add new features to the application. Currently, the
most popular architectures in the Web for Android are MVC (Model – View – Controller),
MVP (Model – View – Presenter) and MVVM (Model – View – View Model)

MVC

In MVC pattern data model is separated from the view and they communicate via the
controller. To be more specific, the model is responsible for handling the business logic and
the data. The view is responsible for visualizing the data from the model. Last, the controller
contains the functions and the logic to update the view when an action is triggered

In Figure, an example is presented. In this example, there is the view, which notifies the
controller when an event happens (e.g. a button is pressed), then the controller interacts
with the model to retrieve and next setup and refresh the view.
MVC separates successfully the view from the model, however the controller has some
disadvantages such as flexibility and maintenance issues. Controllers are tightly coupled to
the views, which makes them less flexible in changes. This means that if the view changes,
then the controller must change, as well. As for the maintenance, over time more and more
code is written in the controller, which makes it difficult to keep track. The solution to the
above issues is to use another architecture pattern such as MVP or MVVM

MVP

MVP is essentially similar to MVC although it uses a presenter instead of a controller. Let’s
take a look again at our previous example. In case MVP was used, the DashboardFragment
would be a view component and the presenter replace the controller with a
DashboardPresenter class, which contains all the functions and the logic to update the view.

MVVM

In MVVM, there is no controller or presenter, but a View Model class. This class implements
all of the functions needed and the difference from the other two patterns is that the data
binding happens in xml using View Model class. The data from model are saved in
“Observable” objects. In this way, the testing is much easier because there is no
dependency on the view. All one has to do is to verify that the observable objects have
changed when the model changes. However, the problem of maintenance still exists,
because extra logic is added on xml files, which can make them bloated.
Conclusion

It seems that MVP and MVVM have fewer disadvantages than MVC, but they add more
complexity to the app. They may, theoretically, solve the problem of flexibility but the
problem of maintenance still exists. In any case the difference in flexibility is the degree of
the coupling between the view and controller (MVC), the view and presenter (MVP) and the
view and ViewModel (MVVM), namely the coupling in MVC is tighter than in MVVM, but it
still exists. Our point is that the developer still would make changes in the
controller/presenter/viewmodel, if a change in view is needed. Therefore, there is not really
a difference between these patterns; the logic is the same. We chose for our application the
MVC pattern, because the other ones add more complexity.

Android libraries
For the development of the application, the Support Library of Android and other third party
libraries were used, which are popular to the development community as discussed in Stack
Overflow, an online community for developers to ask questions, learn and share knowledge.

The Support Library provides a wide range of classes from fundamental app components, to
user interface widgets, media handling, TV app components etc. The library also handles the
backwards compatibility among the multiple API versions (OS versions) of Android, when
new features are added or older features are improved. Initially, the support library was a
single library, but it gradually evolved into a suite of libraries, which are fundamental for the
development of the application, especially if the developer wants to follow the Google’s
guidelines of Material Design.
In this project the following libraries of Support Library were used:
1. App Components:
'com.android.support:support-v4:25.3.1' 'com.android.support:appcompat-v7:25.3.1' These
libraries are used in all Android projects, as they provide backwards compatibility for core
platform classes and features, such as Activities and Fragments (support) and Toolbar
(appcompat) .
2. Material Design:
'com.android.support:design:25.3.1' They provide components for implementing the
Material Design guidelines.
3. Graphics:
'com.android.support:support-vector-drawable:25.3.1' They provide support for vector
drawable implementation in the application. The benefit of vector drawable is that multiple
PNG images can be replaced with a single vector drawable defined in xml.
4. ConstraintLayout:
'com.android.support.constraint:constraint-layout:1.0.2' This library provides the
ConstraintLayout UI component, which allows the development of a responsive layout in an
Android application .
5. CardView: 'com.android.support:cardview-v7:25.3.1' This library enables the support of
the CardView component, a rectangle view, which can be customized easily with a set of
properties, such as rounded corners, shadow etc. Before the integration of this library, the
developers had to develop by themselves all these features.
  Website referred while developing project
https://onix-systems.com/blog/how-to-create-a-fitness-app-and-generate-
revenue-with-it

Onix has over 20 years of software development experience, fitness including

custom mobile app development for Android and iOS and wearables. 
Our experts provide a broad range of development services from A to Z for
startups, small and medium-sized businesses worldwide. We can execute your
fitness app project according to approved requirements and within your
budget. Onix can also assist with leveraging the most suitable, up-to-date
technologies as the changing market or your business objectives may demand.

https://repository.ihu.edu.gr/xmlui/bitstream/handle/11544/29049/
Kagkini_Thesis.pdf?sequence=1