To Be Determined: The Get-A-Life Solution

Nicholas Diley
University of Advancing Technology, nicdiley@uat.edu
Zachary Beauchamp and David Small
University of Advancing Technology, zacbeauc@uat.edu, davsmall@uat.edu

Abstract The purpose of this application is to suit the

requirements for the University of Advancing Technology
Mobile Platform Software Development Class (CSC330).
Our application exists to allow the user of the application
to find events around the surrounding area that could
best benefit the users interests. This would contain sales
of certain items, open invitations to local events, and
many more, where based on the users input in the initial
setup of the application, our application will be able to
send push notifications and event reminders to the user
in question. Utilizing GPS Services, location based events
may be implemented, based on a radius of travel, where
push notifications and emails may be sent to the user in
response to potential interests, along with potential
directions from the current location to the location of the
event/point of interest.

Index Terms GPS Services, Location Based, Push

Notifications, User Interaction

Google maps API

Display current user location
General map data
Android Studio
Develop app
Basic Android functionality
Google Places API
Place events on map
Show event data
SQL
Store event information
Transfer information between users
Application widgets
Displaying information crucial to the user
Push notifications
Detailed information about certain aspects
Pulling event information
Pulling Location Information
Displaying such information
Collection Widgets
Displaying multimedia information
Including but not limited to:
Gallery/Pictures
List elements
Such as events or items

Where you are able to browse such

elements and open them accordingly.
Control Widgets
Buttons to enable or disable certain
features
This would also be involved with the
physical hardware of the device
Including but not limited to:
Wireless Capability (Wi-Fi)
GPS Communication
Screen Rotation
Mobile Data
Near
Field
Communication
(NFC)
Could also be closing the application or
limiting the scan/download radius
Such as limiting the radius of which to
search for events or the setting for push
notifications.
GUI Elements
Dialogue Boxes
User-friendly design
Dialog boxes for location entry
and event creation and interests
Button for event acceptance or
denial
Button for settings menu

Work Process
For usage within our project, we will be following the 10
key principles of Agile:
1. Active user involvement is imperative
2. The team must be empowered to make decisions
3. Requirements evolve but the timescale is fixed
4. Capture requirements at a high level; lightweight
and visual
5. Develop small, incremental releases and iterate
6. Focus on frequent delivery of products
7. Complete each feature before moving on to the next
8. Apply the 80/20 rule
9. Testing is integrated throughout the project
lifecycle test early and often

10. A collaborative & cooperative approach between all

stakeholders is essential
Keeping ourselves active in the project is an absolute
requirement, as we will each be pulling our own weight and
working together. We will also be making decisions together,
as this is a project we must remain involved in.
Our project has continued to grow, starting as a small
application that uses GPS locations to an active event
planner that will be notifying us of events that would pertain
to us within our general location.
Throughout the lifespan of our project will be begin sprints,
to develop key features within our application. We may also
utilize the waterfall methodology as so:
1. Conception
2. Initiation
3. Analysis
4. Design
5. Construction
6. Testing
7. Implementation
8. Maintenance
For now, we will focus with Waterfall in mind, while also
taking into account the key principles of Agile.
Within the first two weeks of the class in session, we have
undergone the conception of our project, To Be Determined:
The Get-A-Life Solution. With this in mind, we have also
begun work within the Advanced Software Development
(CSC413) class as well, further understanding of our
knowledge of Android Application development and more.
Initiation of the project has been underway, as we have been
dividing up the bits and pieces of the application of which
we will be working with:
Working with the google maps and places API
Creating the GUI
Search Results & Event Viewer
Creating Pins for visual representation on the
Map
Possibility of a central database
This is just the start. Design processes has been completed as
well as we have undergone further work with Ninjamock to
try and conceptualize what our application will be looking
like. The storyboard has helped greatly in visualization and
an idea on button placement along with functions and other
key pieces.
Going into Week 7 and 8, we will be working on the
construction of the application. Working out of class as a
group we will be putting the pieces together and get an idea
on what we need to do to properly implement the application
pieces. It has been divided amongst us to conduct research
on utilizing the google API as previously mentioned, where
we will need to create pins or events that will be shown on
the map to properly create events for the sake of our project.
Current Schedule:
Week 1: Conception

Week 2: Conception
Week 3: Initiation
Week 4: Analysis
Week 5: Design/Analysis
Week 6: Design/Analysis
Week 7: Construction
Week 8: Construction
Week 9: Construction/Testing
Week 10: Testing/Implementation
Week 11 & Further: Maintenance/Implementation
Meetings are to be held on the Thursday & Sunday of each
week, to collaborate on our research and come up with what
we are to do thus far.
Total Estimated Time Meeting: 3.5 Hrs
Estimated Avg Time/Meeting: 25 Minutes

Completed Work
To Be Determined: The Get-A-Life Solution has the
following features implemented:

Google Maps Pins

o Creation & Deletion
o Dialog Box Generation
Name
Address
Description
o Long Press
Slider to Toggle Deletion
Location Based Services
o GPS Approximation
o Coordinate Location Data

TBD has been tested on two devices in particular thus far,

where the versions of Android used are Android 5.0.1 and
5.0.2. Based on current settings of the application, it should
work across multiple platforms as long as the current OS
used is Android 5.0 (Lollipop) through Android 6.0
(Marshmallow).
The application has GPS functionality where it is able to
track the users approximate location (assuming that location
based services are allowed on the device). Upon receiving
this data, the application will automatically focus on the
location of the user, where they have free reign from there to
create new events. For further debugging, we have included
the interface to view the approximated location in
Latitude/Longitude coordinates.
Unfortunately we were not able to make the cut for
developing the function for sharing of events, and a central
storage for the events as well, as that has become a stretch
goal for the project.

For the time being, To Be Determined is to be determined in

the sense of continued support, where the current
functionality is an overlay of Google Maps where we can
create custom pins and remove them with ease with
customizable dialog box.

Screenshots

Utilizing the long press function within the application, we

are able to create dialog box as shown below:

Below you will find visual representation of the various

aspects of our application: To Be Determined: The Get-ALife Solution.

To Be Determined is an application that is focused around

the Google Maps API, of which we are able to create an
overlay to create events for usage within the application.
The initial concept was going to be an events coordinator,
where there would be a menu of events that can be tracked
on the map in real time, and you would be able to receive
alerts based on geographic location and proximity to the
location as such.

This dialog box allows for the creation of markers by

assigning it a name and a general description/address for it,
however based on GPS location and the presence of the map,
we will be able to quickly ascertain the roads needed to
travel, and general distance away from the location.
The main functionality will be the ability to create and share
pins with others, having them appear on the maps of those
interested.

Above is an image that details the creation of a pin, detailed

to be a Party in Frys Parking Lot running from 12:00 PM
12:00 AM. With the proposed functionality that we were
trying to implement, we would receive alerts based on
proximity to the target, whether it was underway, or if it was
starting soon.
The idea for this would be to store this information on a web
server to pull and push information from, however this
functionality was not able to be met as we were running into
issues with the overlay.

Finally, above you will find the Frys marker has been
deleted and was replaced by a marker along the Canal
behind UAT. This is done by toggling the function to delete
markers, where upon doing so, will delete the marker from
those currently set, along with all information attached.
This could be useful for clearing events that have already
transpired, or perhaps deleting events that you are not
interested in based on prior criteria.

Sprint Process
Sprint One Sunday 10/25/2015
Start Time: 1:30 PM
We began work with the initial development within Android
Studio. To start with, the Google Maps API has already been
implemented within Android Studio, where we have all of
the GPS awareness tools, and location based tools that we
will be using for our location based events. Google Places is
within the Google Maps API of which we will be altering it
to fit our needs within our GUI and be able to set the
parameters necessary.
Designated Lunch/General Break: 3:45 4:05
What we will be looking for is the possibility of a local
database to store events, or create some sort of small
webserver for testing purposes. Within this database will be
the set events and to be able to get everything put together.
Google Maps/Places does implement to a certain extent,
however what we are after would be the possibility of
extending it further.
We have previously implemented a Gitlab setup for the
application, along with our independent projects and projects
for other classes, so it has been a process to learn how to
properly implement it. GUI is still a work in progress,
however we are still conducting studies on the Google
Maps/Places API to better understand how to pull and push
information. We have been looking into background
processes to run to alert the user of any new kind of event,
however we may take that into a different perspective and
have the notifications be set based on a certain timeframe or
proximity of the location through the general GPS qualities.
End Time: 5:30 PM

not be the case. The Google Places API information is stored

Google Side, so to be able to alter this information to add in
our own would be far from the most optimal experience.
Rather we thought about overlaying an event that would be
created on click that will be over the Google Maps API,
where we will be going in with the mindset of dropping a
pin on the map and creating an event based off of this mark.
This will involve the customizable menus that will be able to
store the event locally within the device, having a saved
events section that will be able to be loaded up and we are
able to see the details of the event.
These will hopefully be able to be shared between users of
this application, where an event that they create will be able
to be viewed by others. This can be accomplished by having
some sort of external database, or perhaps having this
information wrapped up and sent to another user through
some sort of messaging or notification platform.
We are currently working on a way of properly
implementing this:

Create events based on click

o When the user wishes to create an event,
they will be able to tap on a location on the
map and create an event for that spot
Looking up an area based on address
o This can be accomplished with the Google
Maps/Places function
Share events
o Either hosted locally or within some sort
of database.
o How to transmit this information is still in
the works.

End Time: 3:30 PM

Sprint Three Sunday 11/8/2015
Start Time: 12:30 PM

Sprint Two Sunday 11/1/2015

Start Time: 12:00 PM
Since our last meeting on Thursday, we had an objective to
research more into the Google Maps and Google Places API
to better figure out how to create events and various aspects
that will go into the To Be Determined Application.
At first we thought about how we could handle the functions
of the Google Places API, thinking we could take the initial
structure and modify it to our needs for creating new places
and new events, however we found out very quickly that will

Stemming from our previous meeting, we have figured out a

way to enable pins and to set locations within the Google
Maps API so the next step would be concerning making a
popup menu of some sorts to create/track events that will be
associated with the pins. The pins are there for
visual/graphical representation that will be place on an On
Click function, so that a user can pull up the map and tap a
location to set a pin. The Google Maps/Places API will then
be able to pull up the anticipated address for this pin in
particular.
We have already understood that we will need to have some
sort of overlaying event that will be created on click over the
Google Maps API, so our research went into that aspect as if

we can get this function to work, then we will be able to pull

up the interface and push the data where necessary to other
buttons and interfaces within the application.
The expected function is that we can have a map view where
we can see any kinds of events either local to us or those that
were shared with us. We will be able to tap on a location and
set pins to create new events, where we will be able to push
this information to a tab where it will be saved and can be
pulled back up easily where we will be able to store
information such as time, miscellaneous information, and
perhaps number of attendees. We will have to set up some
manner of being able to share this information, perhaps if we
can generate some sort of code within our system or if
Google Maps has a particular way of storing
information/pins, we could share it this way.

each other through usage of the proximity alerts or

transmitted alerts. Storing the information brings us back to
the drawing board in how we would want to do that exactly,
and how to share these events is still something that were
looking into.
The pins and the menus are our highest priority for the time
being, so getting the prompt to generate and being able to
assign information and create events is the main objective
for the time being.
Meeting times for now are a bit unpredictable, however we
should have more to show in our group meeting on
Thursday.
End Time: 4:30 PM

Designated Break: 2:30 PM 3:15 PM

Sprint Five Sunday 11/22/2015

The latter portion of our time was spent trying to get a GUI
up and running. The goal is to open up to a main menu
where we can open up map view of events, or open up a list
of events previously saved onto the device.

Start Time: 12:30 PM

From this we just need to tie in the Google Maps activity as

there is one inherently within Android Studio, and open that
up into a new scene and be able to traverse it where
necessary. Inherently it already has the ability to open up the
Google Maps application, and pull up directions; what we
need to do is to pull/push the data to the proper locations.
End Time: 4:00 PM
Sprint Four Sunday 11/15/2015

Stemming from the last few weeks, we have been running

into some major functionality issues in regards to our
application. The On Click and On Create events that we
have within our application have not been functioning as per
our standard or what we wish of them, which is creating
major problems and causing it to crash overall.
The problem has been looked over, however within the
Android Studio debugger, there is little to no information
being disclosed in regards to the error except for references
to NULL pointers and other variables. We are able to get the
map interface up and running just fine, however creating the
On Click events has become a struggle and will either:
Not work or crash the application.

Start Time: 2:00 PM

After going through the past lectures, we have more
information on how to use proximity alerts and the potential
on creating an overlaying menu to go along with our pins
that we would be using within our application. For the most
part, we have worked on this a bit more, where Zachary has
been putting in extensive work into working with the Google
Maps API.
The goal as before is to utilize pins within the menu and to
generate a prompt or a pop-up menu with specific functions
based on the event, such as creation, edit, and to find more
general information as well. We are still working on the GUI
portions of it as well, getting everything to function properly.
Break: 3:30 PM 4:00 PM
From this point its more of a matter of finding out how each
of these prompts and functions work. We have a general idea
of the functionality that we will need for these events, and
we are still unsure how we want these devices to relate to

We have ran into issues regarding Java as well, in the sense

that there should have been a pre-requisite for Java before
going into this class as it is very Java heavy. Nicholas and
Zachary have very limited knowledge with Java, mores-o
focusing on C# and C++ in past classes. This has led into
errors and difficulties concerning Android Studio as a whole.
Consideration has been made into changing our platform or
making a last minute change to our group project, including
switching over to a Calendar Manager as proposed by
Zachary or creating the Unofficial WhoHasIt Android
Mobile Application as proposed by Nicholas. We have also
taken consideration into completely switching the platform
from Android Studio to Unity as we have had weeks spent
on learning how to utilize the Unity mobile interface and we
have the capabilities of easier access and more feasibility
within the Unity Web Player and events functionality.
However, for now we are focusing on making sure that we
have exhausted all options before we make a radical change
to the application as a whole. We are continuing to look into

the maps functionality and creating the events while also

trying to make sure that the UI works and that we have
something we can present by Week 15. We expect to have
more group meetings and more asynchronous study to
satisfy this need to make our application function.
Break: 3:30 4:00 PM
We are taking consideration into switching our project,
however we will come to a full decision if we are unable to
figure out the event functionality and trying to get it to tie in
within our application. If we can create events, then we are
already onto the latter steps that we need to wrap up our
project. The only issue is actually getting it to function and
to prevent the application from crashing on startup when
performing USB debugging. The ADK version seems to
have some conflictions between the device and the
emulation software, so that may be a problem to start with.
For now we will be looking into the issue more and try to
come up with other solutions. This may involve recreating
our code from scratch to satiate this purpose, however we
will just have to see as this next week goes by.

and Google Maps to get the best possible direction and

estimated travel time to the destination.
Proximity is something that we have been debating
implanting into the application, where we can have alerts go
out whenever we are within a certain distance from the
target, however that is still a work in progress.
All of that aside though, we are making great progress this
week as opposed to the last few weeks after discovering
these Google Map API resources, which have helped
immensely in getting the functionality we needed. From here
its a matter of tweaking it to our own design, and
customizing it to work with TBD.
In summary, we worked on getting and displaying the
current location using a marker within the maps interface,
animating the camera to focus on the marker, clicking on the
marker, and finally, deletion of the marker. One of the larger
aspects is finally coming to a close since getting the google
maps functionality to work has been one of the larger
hurdles.
End Time: 5:15 PM

End Time: 4:45 PM

Sprint Seven Sunday 12/6/2015
Sprint Six Sunday 11/29/2015
Start Time: 1:30 PM
Start Time: 1:00 PM
Since last week, we have found numerous resources that
have helped us along with the foundations of the Google
Maps API immensely. The tutorial detailed the workings of
the markers and how to set them, along with finding the
current location or set location along with moving the
camera accordingly.
With these assets in place, we have been working on getting
the animations to work correctly, along with setting and
deleting markers wherever they are placed.
The goal is to be able to set a marker and work with a menu
that may or may not pop up upon being placed, and then
creating an event (most likely storing it locally within the
device). From there we are going to have further details
associated with these events, ranging from sharing and then
deleting the event, where we are still working on the
functionality of deleting the marker and all data associated
with it.
One issue that we have ran into thus far with this process is
that once a marker is placed, it the camera will snap back to
the marker after a short period of time, which may prove to
be difficult to use should the user be tracking where they are
in relation to the marker. Next up would be tracking the
distance or having some sort of correlation between the app

As compared to last week, we have made significant

progress into the application, in regards to map settings and
getting functionality with dialog boxes and pulling
information. Our current situation allows for the placement
of pins on the map interface, which allows us to find the
current coordinates in latitude/longitude format as well. This
would be useful within the Places API to be able to try and
estimate the address at the current location, or have a place
where we can input an address to have a pin set at that
location.
With combined efforts, we have figured out an XML parsing
error that had existed the night before, which was the portion
that worked with the custom window for text addition, of
which we have resolved since then. From there however,
when we created the info window, we figured out that it
renders the content as an image so we are unable to alter the
live view.
We have since then replaced the Edit Text objects with
Text View objects, where we are currently working on the
dialog box for the location/address and the name of the event
appear on the map interface. We have been working on
creating our custom layout, which is visible upon clicking
the marker.

Markers can be made with a long press on the map, where

we plan for them to host information, however coordinating
this with the Google Places API is still unknown.
Further changes will be changing the long press from a
marker placement to dialog box creation, then the dialog box
will create marker, since we will be able to edit the address
right then, and have it place it onto the map. We also plan on
using an array to store the markers that way we can manage
those currently placed, and all future markers to be placed.
End Time: 6:00 PM
Sprint Eight Sunday 12/13/2015
Start Time 1:30 PM
As we are wrapping up the end of the semester, we have
obtained general functionality across our application. One of
the biggest milestones that we had to accomplish was the
creation and deletion of pins on the Google Maps overlay,
where we could create the pins with ease however we found
ourselves unable to delete them. This turned out to be a
misplacement of the maps.clear() function that was being
implemented within our app, where it wasnt being called in
the right area to get it to function correctly. We have since
resolved this issue and have obtained the ability to create
and delete the pins without any fuss, where we can add
description information such as the name of the event and
location where necessary.
We have run into quite a few problems in regards to the
Google Maps API and how everything was set up, so
building the overlay that we have proved to be a struggle all
on its own throughout these weeks. Most resources that we
had were built around older versions of the Maps API as
well, so it was a little difficult to get the pieces that we
needed to function correctly overall by getting all of the
settings right. Our group members also did not have a strong
foundation in Java as well, which proved to be a hurdle to
pass.
These problems aside, we do have a functional prototype of
our application, of which we are eager to show off and to
potentially work on in the future.
End Time: 5:30 PM