Mobile App Development

GCTU Blogger App PowerPoint Presentation

Philip Worlanyo Amevuvor
0501200008
Application Fundamentals
• Android apps nowadays are written using Kotlin. The Android SDK tools
compile your code into an APK or Android App Bundle, along with all data
and resource files.
• Our Android package is in an archive file with a .apk extension that contains
the content of our app, required at runtime and is the file that Android
devices will use to install the app.
• An Android App Bundle, an archive file ending in .aab , contains the
contents of the App Project and also contains some additional metadata
that is not required at runtime. AAB is a release format and cannot be
installed on Android devices. When you distribute your app through Google
Play, Google Play's servers generate optimized APKs that contain only the
resources and code needed by the specific device requesting to install your
app
Android Application Components
• App components are the key building blocks of Android apps. Each
component is an entry point through which the system or user can access
your app. Some components are dependent on other components.

There are four types of app components:

- Activities
- Services
- Broadcast receivers
- Content providers

• Each type serves a specific purpose and has a specific lifecycle that defines
how components are created and destroyed. The following sections
describe the four types of app components.
 Activities
• Activities are entry points for interacting with users,
represented by a single screen for a user interface. The
Sign In page is an example of an activity. Activities drive
the following important system and app interactions:
• Track what the user sees on the screen to ensure the
system is still running the process hosting the activity.
Previously used processes contain things that the user can
revert (stopped activities), so maintaining those processes
is a priority.
• Allows the app to terminate the process so that the user
can return to the original state. It also provides a way for
apps to implement user flows between apps and for the
system to coordinate those flows (The most typical
example here is sharing blogs and other content to users
and externally to other applications)
 Services
• Services are the universal entry point to keep your app running in the background for any reason. This is a
component that runs in the background to perform long-running operations or work with remote
processes. Services do not provide a user interface For example, there is a service that retrieves data over
the network to update an app's blogs and articles This can be achieved without blocking user interaction
with the activity another component. Activities can start and run services or bind to and interact with them.
• A started service tells the system to keep the service running until it completes its work. We use started
services in our app to sync data with the server and download/update content in the background even after
the user exits the app.
• Playing video is something the user is directly aware of, so the app tells the system it wants to be front and
center. In this case, the system knows that it should try to keep the processes of this service running. This is
because users get frustrated when processes disappear. Background services are not aware of by users,
allowing the system to manage processes more freely. The service can be stopped (and restarted after
some time) if the user needs the RAM due to a pressing problem.
• A bound service is running because another app (or the system) has requested to use it. It's basically a
service that exposes an API to another process, so the system knows there are dependencies between
these processes. If process A is bound to process B's service, we know that process B (and its services) must
keep running for process A. Also if process A is of interest to the user then process B will also be treated as
being of interest to the user.
Home Page
• The homepage of our application implements a search
function. The blog and user data is stored in a database
provided by firebase. The search feature searches through
the blog for easy and intuitive user access.

• There is a Sidebar menu function on the main page of the

application allowing users to easily access the Home page,
Bookmarks(which will be saved blogs from other
publishers) and user written blogs under my blogs.

• There are navigation buttons just above the blog view

allowing users to access the news, top trending articles,
catch up with issues and concerns involving Hostel life,
information and activities hosted on the Main campus and
Business School.

• Each blog has a convenient and easy to access share

button, allowing the user to share blogs to other bloggers
on the GCTU blogger app or externally to other social
media and messaging applications.
• When a new user registers on the GCTU
blogger app, they will be asked to provide data
such as their Name, Email, course, bookmarks,
photo, student ID and input their Student year.

• Blogs created by users on the GCTU blogger

app will contain fields as follows, Blog,
ID(Chosen as our primary key), Title, Content,
Thumbnail and author ID

• The Blog editor is a simple and intuitive text

editor supporting all the various formatting
and insert capabilities, to edit or start creation
there is a simple pen tool at the bottom right
corner which brings up the keyboard and
cursor

• When the user is satisfied with their input,

there is a simple post button which will appear
at the bottom right corner of the input text to
post it to the app’s front page