Beruflich Dokumente
Kultur Dokumente
A Project
MASTER OF SCIENCE
in
Computer Science
by
Vineeta Bhagbole
FALL
2015
REMIND MY SCHEDULE – ANDROID APPLICATION
A Project
by
Vineeta Bhagbole
Approved by:
____________________________
Date
ii
Student: Vineeta Bhagbole
I certify that this student has met the requirements for format contained in the University
format manual, and that this project is suitable for shelving in the Library and credit is to
iii
Abstract
of
by
Vineeta Bhagbole
In today’s fast paced life, keeping track of all the events which has travel schedules is a
tedious task. Though there are number of event reminder and calendar applications
available for android, none of them supports dynamic reminders based on user’s current
location. All the current available applications give an event reminder before a fixed
Also, in the current available apps, a user has to separately feed information about all the
events with travel plans for which he/she wants to get reminders. A user can set a fixed
time for notifications to be sent before the event occurs. This requires estimation of the
time required for travel to reach the destination location from a fixed start location and
accordingly set the notification time to avoid delays reaching the destination. This
estimation goes wrong if user starts travelling from different start location. This could
iv
With my “RemindMySchedule” android application I am proposing a solution to the
above problem. This application will send dynamic notifications based on user’s current
location, mode of travel, and importance of the schedule. App will automatically sync
only those events which have travel information and send dynamic notifications.
Notification will also include travel route information for users to start navigation.
“RemindMySchedule” also provides the event specific location sharing among selected
The application has been implemented using Android and its services for the front end.
_______________________
Date
v
ACKNOWLEDGEMENTS
I would like to express my gratitude to Dr. Jinsong Ouyang, my project advisor for
develop the skills towards Android Application Development. I thank him for his
successfully.
In addition, my gratitude is extended to Dr. Jun Dai for his willingness to serve on the
committee.
Lastly, I would like to thank the entire faculty and staff of the Department of Computer
vi
TABLE OF CONTENTS
Page
Acknowledgements ............................................................................................................ vi
Chapter
1. INTRODUCTION .........................................................................................................1
vii
3.1.3 Services .........................................................................................................14
viii
4.6 Check-In and Location Sharing .............................................................................48
5. CONCLUSION ............................................................................................................65
References ..........................................................................................................................66
ix
LIST OF FIGURES
Figures Page
x
Figure 4.5 Set Event Policies .............................................................................................39
Figure 4.9 Event Details with Default Policies and Settings .............................................56
Figure 4.10 Travel Time to an Event with Default Policies and Settings..........................57
Figure 4.11 Dynamic Notication for an Event with Default Policies and Settings ...........57
Figure 4.12 Event Details with Customized Policies and Settings ....................................58
Figure 4.13 Travel Time to an Event with Customized Policies and Settings ..................59
Figure 4.14 Dynamic Notification for an Event with Customized Policies and Settings ..59
xi
1
Chapter 1
INTRODUCTION
There are bunch of schedule reminder android applications available today on play store
providing static notification to user before a specified interval of time. The static
notifications will not be proven to be useful when travel time for user is considerably
large with respect to reminder set for fixed time. Also this could cause delays in arriving
application which dynamically notifies user so that they can be on or before time for an
event.
The application extracts event details from Google calendar. The event details are
the data with Google calendar. It will run in background to access the user’s current
location and calculate travel time with respect to mode of travel selected by user. The
application allows user to edit/modify each schedule to set the importance as well as
mode of travel. Also user can do profiling for location access and reminder settings.
Based on the provided details and policies set by user the application will intelligently
notify user about the scheduled event. The notification sent to user also includes the
RemindMySchedule also has a very useful feature of location sharing among group of
friends when they have common event. By using this feature a user can find out where
their friends are with respect event location. Also it does not require texting or calling just
to find out exactly where your friend is while they are driving or doing some other work.
3
Chapter 2
PROJECT REQUIREMENTS
reminder application. This application not only keeps track of scheduled events, but also
Figure 2.1 shows all the functionality based operations that can be performed by user.
The application gets the event data from Google calendar and displays the list of first ten
Figure 2.2 shows the functional flow in application to display scheduled events.
This feature allows user to do profiling for individual events. In this user can edit the
mode for travel, priority and add comments for individual event.
1. Car
2. Transit
5
3. Walking
4. Bicycling
By default the mode of travel is set to “car” and priority is “normal” for all events. Based
on profiling done, user will be notified for an event with travel route to the event location.
2.4 Settings
1. GPS time: It is the interval of time at which user’s current location is checked.
For example, if a user enters five minutes, then his/her location will be accessed at
2. Buffer time: It is additional time used to notify user before starting travel for
event location. The additional time is decided by user as per his/her convenience
1. Buffer time
Time to send notification = Event start time – (Buffer time + Travel time)
Travel time from ‘X’ to ‘Y’ (Mode of travel selected is “car”) is 30 mins.
Notification will be sent 30(travel time) + 15(buffer time) = 45 mins prior to event start.
This feature allows user to share their location with friends and family. The feature will
share their location, user has to check-in their current location. And to view other friends
location user has to add people in a group. Once user creates a group user can see the
location of members in that group on Google maps. In this way user’s friend or family
will be able know the user’s location with respect to event location.
1. Windows
2. OS X
3. Linux
2. Android SDK
3. Android Studio
Chapter 3
Android is a platform architected in the form of a software stack. The stack components
Linux kernel [1]. The operating system is developed by Google and is made open source
so that users can extend the functionality and usefulness of applications. The android
applications are developed in java using android software development kit [2].
distinct purpose and has a distinct lifecycle that defines how the component is created and
content providers. These components are loosely coupled by the application manifest file
AndroidManifest.xml. This file has all the essential information about each component of
1. Activities
2. Fragments
3. Services
4. Broadcast receivers
10
3.1.1 Activities
An activity in android represents a single screen with which the user interacts. A single
application can contain several activities that are bound together. Among these several
activities only can be the main activity which handles the main UI functionality when
application is launched. Though an application can have several activities, only one can
be in active state at a time. Each time when a new activity starts previous activity is
describes the operation to be performed for an activity and type of intents to be received.
<activity
android:name=".MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
</activity>
<activity
android:name=".TabbedActivity"
android:label="@string/app_name" >
</activity>
<activity
android:name=".ProgramEditActivity"
android:label="@string/app_name"/>
<activity
android:name=".ProgramDetailActivity"
android:label="@string/title_activity_program_detail" />
All the activities of a running application are managed in an activity stack and every
activity goes through series of states. The state of each Activity is determined by its
position on the activity stack. When a new activity is started, it becomes active and is
placed on the top of the stack. The previous activity always remains below it in the stack,
and will not come to the foreground again until user navigates back using the Back button
so the next activity down on the stack moves up and becomes active [4].
An activity transition through four states while moving in and out of stack at the time of
Active or running: An activity in the foreground of the screen (at the top of the
Stopped: A stopped activity is not visible to user, but will remain in memory
Inactive: An activity that is killed or not yet launched, it’s inactive. An inactive
Figure 3.1 shows the lifecycle of activity with call back methods that perform operations
3.1.2 Fragments
Fragment is a modular approach to design activity. Fragments are mainly used to build a
activity into modules. These modules are created using Fragment class within an activity.
A single activity can contain multiple fragments to build a multi-pane UI having their
own layout and lifecycle. Fragments are like sub activities that can be reused in different
activities [6].
“CheckInFragment”. Each of these fragments has their own layout in the activity. To
draw a UI layout for the first time onCreateView() callback method used. This method
returns the root of fragment’s layout or null if the fragment does not provide a UI.
Also, a fragment’s code resembles a lot like an activity. It contains similar call back
onAttach() Used in all three fragments to associate the fragment with activity.
on to object beyond the life of view so that the map can be used. The instance
onResume() Used in all fragments. When this method is called fragment becomes
active.
3.1.3 Services
Services does not require user interface. It performs operation with long run-time in the
background. A service does not have an independent thread, it uses of the main thread
from hosting process. For example we can download some files or play music in
<service>
android:name=".services.ShowNotificationService"
android:exported="false"
<service/>
15
In the above code snippet attribute “android:name” indicates the name of service subclass
that implements service. And the value false in “android:exported” tells system that
service can only be started by components of same application. There are two classes-
“Service” and “IntentService” that we can extend to create a started service [7].
A service can handle intents on multiple threads simultaneously. The service base
scheduled event data from Google calendar and calculates distance and travel
even if the component that started service is destroyed. It does not returns any
results to caller, thus once a service has done its task it stops itself.
service, send requests, and get results within same or different processes. A
once it is unbounded.
There are some call back methods which should be overridden depending upon the
implementation, to handle the service lifecycle. Some of the important call back
The broadcast receivers are used to register for system or application events. After
registering, receivers will be notified about the events. For example, applications initiate
broadcasts to tell other applications that some data has been downloaded and is available
for use, so the is broadcast receiver will intercept this communication and initiate
Figure 3.3 shows the two important steps to be done to make BroadcastReceiver works
two dynamically registered receivers are used that receive intents broadcasted by the
follows:
1. BROADCAST_RESULT_FOR_SETTINGS
When user clicks on check-in button in event details window, the application context
at that particular point is broadcasted as results to the setting window. Following is the
tab.
LocalBroadcastManager broadcaster =
LocalBroadcastManager.getInstance(getApplicationContext());
Intent intent = new Intent(Constants.BROADCAST_RESULT_FOR_SETTINGS);
broadcaster.sendBroadcast(intent);
The registered receiver for above intent set the selection of group to one selected in
event detail window. By doing this the result of check-in data on event details window
will be consistent with the data on check-in tab. Following is the code snippet of
19
registered receiver for above intent. ArrayAdapter in the below code is used to
2. BROADCAST_RESULT_FOR_CHECKIN
When user clicks on check-in button in event details window, the application context
at that particular point is broadcasted as results to the check-in window same as it was
broadcasted to settings window. Following is the code snippet where results are
LocalBroadcastManager broadcaster2 =
LocalBroadcastManager.getInstance(getApplicationContext());
Intent intent2 = new Intent(Constants.BROADCAST_RESULT_FOR_CHECKIN);
broadcaster2.sendBroadcast(intent2);
The registered receiver for above intent updates and save the user’s check-in location
on parse cloud. To fetch the user current location ParseGeoPoint() method from parse
android SDK is used. Apart from updating user information on parse cloud, all the
selected group members will receive an email from application account about the
user’s checked-in location. To send the mail to desired recipients on user’s behalf from
application’s email JavaMail API is used. Following is the code snippet of registered
else {
Toast.makeText(getActivity(), "Location not found",
Toast.LENGTH_LONG).show();
}
};
LocalBroadcastManager.getInstance(getActivity()).registerReceiver((receiver),
new IntentFilter(Constants.BROADCAST_RESULT_FOR_CHECKIN)
);
1. JDK Software
consists of tools that developers need to compile, debug and run Java applications.
One can download the appropriate setup version of JDK from Oracle’s website
and follow the instructions of setup wizard to install and configure JDK. And
2. Android SDK
applications. We can download and install android SDK from android’s official
website as an additional package that comes with android studio or the stand-
We can download the android studio IDE from android developer’s website by
clicking on download link. After the .exe file is downloaded click on the file and
features which makes android development much easier. Some these features are
suggestions while writing the code, have sample code templates to build common
application features, able to generate multiple apk file generation associated with
Figure 3.4 Summarizes all the basic steps and development phases involved while
Steps for creating a sample “Hello World” android application are as follows:
1. To create a new android project on android studio click on start a new Android Studio
If a project is already opened select File\New Project from menu to create a new
android project.
Configure the new project by entering the Application name and Company Domain in
text field. The Package Name will automatically get changed based on
the Application name and Company Domain which uniquely identifies an app among
other apps. The Project location holds the project files at specified location.
2. The next screen “Target Android Devices” allows user to select the target android
device for which app will be developed. The option Phone and Tablet is preselected
as the default. The SDK selected from drop down menu is the minimum version of
3. Select a blank activity from “Add an activity to Mobile” window and click next.
4. Then from “Customize the Activity” window user can customize an activity by
changing activity name, layout name, title for activity and menu resource name as
The android project now created is simply a “Hello World” app with some auto generated
Figure 3.8 shows the layout of default files generated while creating a sample “Hello
World” application.
emulator.
Connect the device with system through USB cable, then enable USB debugging
on device from settings > about phone and tap on build number a couple of times
Click run from the toolbar. Choose the connected running device under “Choose
device” window and click ok. The application will get installed and started by
(AVD) under Tools > Android > AVD Manager, select the required device
configurations and click next. Then select the system image for AVD and click
Click on run from the toolbar after AVD is created. Select the launch emulator
option on “Choose device” window. Then select the AVD created and click ok.
Chapter 4
The application installation requires user of app to enter his “name” and “email address”
at login screen. The information entered at login screen is associated with other details
such as user’s check-in location so that they can share location with other app users.
Figure 4.1 shows the login screen popped up while installing application.
The data entered by user at login screen is stored on parse cloud, and to do this data is
key-value pairs one for name and the other for email. Once the key-value pairs are set
userDetails.put("name", name.getText().toString());
userDetails.put("email",email.getText().toString());
userDetails.saveInBackground(new SaveCallback()
{
@Override
public void done(ParseException e)
{
if(e==null)
{
edit.putString(Constants.USERNAME,name.getText().toString());
edit.putString(Constants.EMAIL,email.getText().toString());
edit.commit();
Once user has entered the login information user is prompted to choose an account. The
Figure 4.2 shows the screen where user is asked to choose an account.
contains the registry of user's online accounts. After the user choose an account and
clicks OK, the Google account name will get set by using setSelectedAccountName()
case REQUEST_ACCOUNT_PICKER:
if (resultCode == getActivity().RESULT_OK && data != null &&
data.getExtras() != null)
{
String accountName =
data.getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
if (accountName != null)
{
credential.setSelectedAccountName(accountName);
SharedPreferences settings = preferences;
SharedPreferences.Editor editor = settings.edit();
editor.putString(PREF_ACCOUNT_NAME, accountName);
editor.commit();
}
}
else if (resultCode == getActivity().RESULT_CANCELED)
{
mStatusText.setText("Account unspecified.");
}
break;
case REQUEST_AUTHORIZATION:
if (resultCode != getActivity().RESULT_OK)
{
chooseAccount();
}
break;
33
The application home page will display the list of upcoming events. It extracts/sync events
The application user interface is designed as a tabbed activity in which user can navigate
across the tabs by swiping over views with a title strip on top. The template includes three
To extract the event data from Google calendar AsyncTask class is used. It allows fetching of
event data from Google calendar using Google calendar API call in background using
doInbackground() method which ensures that UI stays responsive. Once the background
thread finishes its task onPostExecute() method is called which publishes the result in main
UI thread. To publish the results on main UI window ArrayAdapter is used. The Array
adapter converts an ArrayList of objects into View items loaded into the ListView (visual
representation) container.
doInBackground() method.
RemindMySchedule application allows user to view event details. When user select an
event from upcoming event list on application home page event details will be displayed
User can find the event date and start time on event details window when user tap on an
event.
Event details window also provides the travel route information to user to have a quick
look on routed path in Google maps. User can view the route information by clicking on
navigate button. This feature helps user to get a prior idea of event location about how far
start a new activity as Google maps with route details from current location to event
location. Following is the code snippet demonstrating the application behavior when user
navigate.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent notificationIntent = new Intent(android.content.Intent.ACTION_VIEW,
Uri.parse("http://maps.google.com/maps?f=d&daddr=" +
program.getLocation()));
startActivity(notificationIntent);
}
});
37
4.3.3 Check-in
This will allow user to check-in his current location and also user can see other
When user clicks on “Check In” button the current activity is closed using finish()
method. And the ActivityResult is propagated back to whoever launched the activity
using onActivityResult() internally. Also the selected group information form event
details window is saved. Following is the code to show the application behavior when
checkin.setOnClickListener((view) -> {
finish();
String groupSelected =
preferences.getString("GROUPNAME"+program.getId(),"");
preferences.edit().putString(Constants.SELECTED_GROUP,groupSelected)
.commit();
TabbedActivity.mViewPager.setCurrentItem(2);
sendResult();
}
});
Once the selected group information is saved TabbedActivity current position is set to
Check-In fragment and sendResult() method is called which broadcasts the results to
Following is the code for sendResult() method where to intents are created named
“intent” and “intent2”. The “intent” is created to broadcast result to “Settings” fragment
LocalBroadcastManager broadcaster2 =
LocalBroadcastManager.getInstance(getApplicationContext());
Intent intent2 = new
Intent(Constants.BROADCAST_RESULT_FOR_CHECKIN);
broadcaster2.sendBroadcast(intent2);
}
RemindMySchedule allows user to set policies for specific event. To set policies for an
event click on edit icon in event details screen. Once user clicks on edit button user will
1. Priority of schedule: A priority can be set to either normal, high and low.
2. Mode to travel: In mode of travel user can specify the transportation mode to be
used by him/her for individual events. Travel mode could be any of the four travel
3. Location sharing group: In this user can select a group with whom he want to
4. Remarks
When user clicks on “edit” icon all the event policies description will replaced by
editable fields and the save button icon will be visible in place of an edit icon. Following
code shows the tasks performed while edit button is clicked for example “View” of the
edit.setOnClickListener((v) -> {
if (isEdit)
{
edit.setImageResource(android.R.drawable.ic_menu_save);
isEdit = false;
remarks.setVisibility(View.GONE);
remarksEditText.setVisibility(View.VISIBLE);
modeofcommute.setVisibility(View.GONE);
modeofcommutespinner.setVisibility(View.VISIBLE);
priority.setVisibility(View.GONE);
priorityspinner.setVisibility(View.VISIBLE);
remarksEditText.setText(program.getRemarks());
modeofcommutespinner.setSelection(program.getWayOfCommute() - 1);
priorityspinner.setSelection(program.getPriority() - 1);
group.setVisibility(View.GONE);
groupspinner.setVisibility(View.VISIBLE);
String groupName = preferences.getString("GROUPNAME"
+program.getId(), null);
if (groupName == null)
{
groupspinner.setSelection(0);
}
else
{
for (int i = 0; i < groupNamesArray.length; i++)
{
if (groupNamesArray[i].equals(groupName))
{
groupspinner.setSelection(i);
break;
}
}
}
}
41
This feature allows user to do profiling on reminder settings. Profiling options include the
following:
1. GPS time in minutes: It is the time interval at which user’s current location is
accessed.
convenience. For example buffer time could be the time required by user to wrap
The reminder settings can be done from “Settings” tab. The above mentioned profiling
options are provided in editable form to user, a user can simply type in the GPS time and
Buffer time as desired. Also user can edit the “Username” and add members in a group
by adding their email ids in selected group. Once all changes are done user can save the
changes by clicking on “Save” button at bottom of the window. Following is the code
save.setOnClickListener((v) -> {
edit.putString(Constants.GPS_TIME, gpsTime.getText().toString());
edit.putString(Constants.BUFFER_TIME,
bufferTime.getText().toString());
edit.putString(Constants.SHOOTING_EMAIL_ADDRESS,
emailAddresses.getText().toString().trim());
edit.putString(Constants.USERNAME,name.getText().toString());
edit.commit();
createAlarm(getActivity());
Toast.makeText(getActivity(), "Saved successfully",
Toast.LENGTH_LONG).show();
42
The application provides a feature to send dynamic notifications to user based on his
current location and mode of travel. The dynamic notification helps user to reach their
event location on time. Notification also includes the travel route information for users to
start navigation. User can navigate to the event location by clicking on notification sent.
To send dynamic notifications to user the application will run following tasks in the
background:
To access last known location of user, device’s last known location is requested
using one of the Google Play services location APIs called FusedLocationAPi.
This API registers for the location updates using a public method called
2. Calculate travel time between user’s current location and an event location.
The travel time and distance between source and destination points is retrieved in
background using Google maps Distance Matrix API. To make a request to retrieve
is used. JSON in the url indicates the form of output. The url is then appended with
the required parameters using StringBuilder. In following code we see that required
parameter append to url are origin (user’s current location), destination (event
returned in the JSON format. The response received is then parsed for text and
urlString.append("https://maps.googleapis.com/maps/api/distancematrix/json?");
urlString.append("origins=");//from
urlString.append(location.getLatitude());
urlString.append(",");
urlString.append(location.getLongitude());
urlString.append("&destinations=");//to
urlString.append(program.getLocation());
urlString.append("&mode=");
urlString.append(wayOfcommuteString);
urlString.append("&sensor=true");
urlString.append("&key=AIzaSyA-Mli_vdtLODqOhizc9ew7oLUFHxu-uog");
System.out.println("URL=" + urlString.toString());
Log.d("xxx", "URL=" + urlString.toString());
return travelDuration;
45
The above two factors ensures that user gets notified prior enough so that they can be on
To setup the reminder for an event “AlarmManager” class is used. This class allows
scheduling an alarm for application that will still be valid even when application is not in
a running state or device is asleep. For this an explicit intent is created describing the
System.out.println("Time Remaining-->" +
timeRemaining/(60*1000)+"minutes");
int id = settings.getInt(program.getId(),0);
if(id==0)
{
id=(int)new Date().getTime();
settings.edit().putInt(program.getId(),id).commit();
}
47
if(!settings.getBoolean(program.getId()+Constants.ALARMSET,false))
{
Gson gson = new Gson();
String programJson = gson.toJson(program,Program.class);
long bufferTime =
Integer.parseInt(settings.getString(Constants.BUFFER_TIME,"30"))*60*1000;
timeRequiredToCommute+=bufferTime;
calendar.setTimeInMillis(timeToShowNotification);
System.out.println("Notification Date" + new
Date(timeToShowNotification).toString());
alarmMgr.set(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
alarmIntent);
}
}
}
}
48
RemindMySchedule also allows user to share their location among group of friends. This
feature is very useful when user needs to share their location with group of friends while
user is driving, or engaged in some other work. This avoids unnecessary call and
messages. By using this feature all users have to do is check-in, and his current location
To implement this feature parse android SDK is used. This SDK allows developer to
build a full-featured android app to store data, send push notifications and manage users.
Each app build using parse has application id and client key applied to SDK install [13].
To store user’s location data on parse ParseObject is used. Each ParseObject has key-
value pairs of JSON-compatible data. For data storing developer has to simply set key-
value pairs, and parse backend will store data. For saving data on parse cloud
parse automatically creates a class and its objectId which is used to distinguish different
sorts of data. The objectId created at the time of saving data on clouds is to retrieve data
The code snippet shows functional flow of application when a user checks-in his location.
49
else
{
Toast.makeText(getActivity(), "Wait for the location",
Toast.LENGTH_LONG).show();
}
}
});
if (googleMap != null)
{
plotGeoPoints();
}
return rootView;
}
i) Go to settings.
iii) Type the group name in “create new group” section and then click create.
3. Type the email address of friends separated by “,” to add them in selected group.
Figure 4.8 shows selecting a group from drop down and email address of the
5. A user can view the check-in location of other users by following two ways:
a) Go to check-in tab to see the location of friends in a group. The Google map
integrated in check-in tab will show the marked location of friends in a group.
To see the zoom-in location of a friend tap on the name and location of
b) Or user can also view the event specific check-in information among group of
Once the user clicks on check-in button they will be redirected to check-in
group of friends. This method does the following task to plot location of friends
i. The emails id’s of the selected group members is extracted from parse
ii. List of objects returned from ParseQuery is individually parsed to get the
“ParseGeoPoint” is used.
54
that application user can have a closer look of friends location on map.
}
55
query.findInBackground((objects, e) -> {
names.removeAllViews();
for (ParseObject parseObject : objects) {
ParseGeoPoint parseGeoPoint = (ParseGeoPoint)
parseObject.get("checkin");
if (parseGeoPoint != null) {
final LatLng position = new LatLng(parseGeoPoint.getLatitude(),
parseGeoPoint.getLongitude());
MarkerOptions markerOptions = new MarkerOptions();
markerOptions.position(position);
markerOptions.title(String.valueOf(parseObject.get("name")));
markerOptions.snippet("Location " + parseGeoPoint.getLatitude()
+ ", " + parseGeoPoint.getLongitude() + " at " +
String.valueOf(parseObject.get("updatedOn")));
markerOptions.icon(BitmapDescriptorFactory.fromBitmap(drawTextToBitmap(R.d
rawable.ic_mymarker, String.valueOf(parseObject.get("name")))));
googleMap.addMarker(markerOptions);
TextView textView = new TextView(getActivity());
textView.setText(String.valueOf(parseObject.get("name")));
LinearLayout.LayoutParams llp = new
LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT,
LinearLayout.LayoutParams.WRAP_CONTENT);
llp.setMargins(0, 10, 0, 0);
textView.setLayoutParams(llp);
textView.setTextColor(Color.BLUE);
textView.setTextSize(20);
textView.setTypeface(null, Typeface.BOLD);
textView.setOnClickListener( (v) -> {
moveToCurrentLocation(position);
});
names.addView(textView);
}
}
});
}
}
56
To validate the feature of dynamic notification some dummy event entries are added to
“RemindMySchedule” application. The upcoming event entries are then used to test the
dynamic notification for events with default policies and settings, and also for the
customized ones to verify the full functionality of dynamic notification based on mode of
commute.
1. Steps performed to validate the dynamic notifications for events with default
a) Figure 4.9 shows an upcoming event details with default policies and settings.
b) Figure 4.10 shows the travel time to event location when mode of commute is
Figure 4.10 Travel Time to an Event with Default Policies and Settings
c) Figure 4.11 shows the dynamic notification for above scheduled event.
Figure 4.11 Dynamic Notication for an Event with Default Policies and
Settings
58
= 10:56 PM
2. Steps performed to validate the dynamic notifications for customized event policies
a) Figure 4.12 shows an upcoming event details with customized policies and
settings.
b) Figure 4.13 shows the travel time to event location when mode of commute is
Figure 4.13 Travel Time to an Event with Customized Policies and Settings
c) Figure 4.14 shows the dynamic notification for above scheduled event.
Figure 4.14 Dynamic Notification for an Event with Customized Policies and
Settings
60
= 2:14 PM
location between groups of friends having common events. To validate this feature
1. A common event “Group Study” is created by two users: Vineeta and Chandler.
Both application users create their own group and select the relevant group to a
Figure 4.15 shows the event details window of a common event between two
different users.
Note: While creating group user can give any name to group as they like.
Figure 4.16 shows the members of selected group on event details window for both
users.
Note: The group members were added using email id of the users.
2. The two application users check-in their location from associated event details
window. The checked in location of users is then broadcasted among members. And
Figure 4.17 shows the check-in window of two different users from the group.
This application intelligently notifies user about the event prior enough so that user can
reach event location on time. It also provides the travel route information by
automatically extracting the event location from database so that user does not have to
separately navigate for event location. The accuracy and efficiency of application to send
dynamic notifications relies upon the profiling done by user. The accuracy of notification
is directly depended upon the frequency of location access. More frequently the location
is accessed more accurate is the result. But frequent location access while application
runs in background could reduce the battery life of device. To prevent this application
can be optimized with an adaptive approach or some algorithm for location check to save
the battery life. The algorithm design should allow application to automatically adjust
the frequency of location check based on event day, time and time left for event.
65
Chapter 5
CONCLUSION
This application is intended to be more useful than existing schedule reminder application
by offering dynamic notifications to user. The application manages the event schedules
for user by keeping track of all the scheduled events. It runs in background to access
user’s current location and also calculates the travel time needed depending upon the
mode of commute. The calculation results are then used to notify user dynamically.
This application also offers an important feature of location sharing among friends. The
REFERENCES
http://www.techotopia.com/index.php/An_Overview_of_the_Android_Architecture.
2015.
http://developer.android.com/guide/components/fundamentals.html. Accessed in
July 2015.
2015.
[5] Best android training. "Android Project Structure and Activity Life Cycle." [Online].
Available: https://bestandroidtraining.wordpress.com/2013/03/30/android-project-
http://developer.android.com/guide/components/fragments.html. Accessed in
October 2015.
67
2015.
http://developer.android.com/reference/android/content/BroadcastReceiver.html.
[9] Google Inc. "Installing the Android SDK | Android Developers." [Online].
2015.
[10] Google Inc. "Android Studio Overview | Android Developers." [Online]. Available:
2015.
[12] Google Inc. "Running Your App | Android Developers." [Online]. Available:
http://developer.android.com/training/basics/firstapp/running-app.html. Accessed in
July 2015.