DartCal Design Spec

Will McConnell, Paul Champeau, Lisa Luo

Overview

DartCal is a simple schedule sharing app for Android. The target user is a Dartmouth student,
professor, or anyone in the Dartmouth community that is familiar with the Dartmouth block
class schedule. DartCal will allow you to set and view your basic weekly course schedule, with
toggles for x-hours and office hours. It will allow you to add your friends and share your
schedules, with schedule overlay functionality for ease of mutual free time visualization. The
termly calendar will also provide useful information about important termly deadlines.

User Interface Implementation

Weekly Tab



The first tab will be the display of the users own weekly schedule on the Dartmouth weekly
schedule diagram. In the settings menu of the menu bar, there will be checkbox options for
toggling the display of office hours and x-hours. There will also be an Edit Profile option that will
allow the user to set his or her information, including Name and Class Year for ease of search
options, and information to fill in for up to 4 classes.


The information from the Edit Profile activity will be saved to a database, which will then be
pushed to the cloud for querying / sharing with other users.
The above views will all be implemented as ScrollView views. Save and Cancel buttons will be
at the bottom of the Edit Profile activity.

WeeklyTabFragment.java
Displays calendar view with user schedule data
EditProfileActivity.java
Saves user profile to database & cloud
UserEntry.java
User information object
UserEntryDbHelper.java
Helper to wrap user information to database entry

Friends Tab



Our second tab is what truly inspired DartCal--the ability to view and interact with friends
schedules so as to improve the feasibility of scheduling group activities (ie lunch, afternoon
trips, or even group projects). Currently, the only way to schedule a group event is to either
memorize friends schedules or to share your calendar via some cloud service (iCloud or Google
Calendar). Neither of these options are very feasible for the dynamic scheduling needs of
Dartmouth students. Our android application will make this possible because it will be custom
tailored to the needs of dartmouth students. To accomplish this, we will use a similar layout the
first tab, but with the added feature of displaying friends schedules transparently layered on top
of one another. This will allow the user to quickly identify which friends have certain classes
while also making it visually intuitive which blocks of time are free for different friends. In the
options menu, the user will be able to toggle which of his friends schedules he would like to
view. This will key feature allows the user to group his friends based on their relation to one
another (ie project partners, close friends, or teammates). Toggling which schedules to view will
also keep the UI from becoming too cluttered to be truly effective.
To implement these features we will use the same weekly calendar framework that we
develop for the weekly schedule tab, but with a few added classes and database interactions.
We will need to implement a Friend class which will contain all the pertinent information for a
users weekly schedule--things like unique database row identifier and an array list of all of their
calendar events. When a friend is added by the user, the corresponding entry will be
downloaded from the cloud datastore and then inserted into the local database. In addition to
the Friends class we will also need a class create the database, as well as hold different database
helper functions. Similar to the MyRuns labs, we will implement methods to fetch an entry from
the local database by its unique row identifier, insert an entry into the database, and do any
needed data conversions pre or post fetch/insertion. After adding a friend the user can then
interact with him by creating events and then inviting certain other friends to join. Upon
accepting the event invitation, the event will be added to each corresponding users event list,
which will then be uploaded to the cloud datastore.

FriendsTabFragment.java
Display Friends tab view with options menu of friend list
FriendEntryDbHelper.java
Helps fetch friend information from database
DartCal_AppEngine.java
Server handler for app

Term Tab

The third tab will offer a service to users that will fill three separate needs. First of all, the tab
will allow users to post their own termly calendar so that they can easily view when their
midterms, formals, parents weekends are. Next, the app will allow users to view the campus
schedule in a more organized fashion. Finally, this tab will allow anyone in the Dartmouth
community to post an event, so that all others can view it.
There is currently no easy way to organize and view the hundreds of events that occur on
campus each week, so we feel this will make the app very applicable for the Dartmouth
community. Currently, students and faculty have to wade through blitz to determine when and
where events are occurring on campus. There is also no calendar view of these events, so our
app offers a method of consolidating all the information into a clean, user-friendly interface.
Eventually, we may need to add some kind of filtering system so that only legitimate events can
get posted, but we will not add those kinds of features just yet.



When the user selects this tab, a list view of two buttons will appear, one labeled
Personal Calendar, the other labeled Dartmouth Calendar. If the user selects Personal
Calendar, a list view of buttons will appear, each one corresponding to a separate week of the
term (ie Week 1, Week 2). When one of these buttons is selected, a calendar view will be
presented, with each day of the week being allocated a portion of the screen. The user can then
click on an add button located in the tool bar. This will then fire an activity to an input screen
where the user can input information regarding the event and click save (similar to Manual Input
Activity in MyRuns). This information is then saved to the database, and the user is returned to
their personal termly calendar, where the new event that they just entered is now displayed.
The user can then continue to add events to this calendar, and these events will be saved
permanently so that they can be viewed at any time. Events can also be deleted using a delete
button, also in the tool bar.



If the user selects Dartmouth Calendar on the other hand, the user will be able to view a
public calendar for the whole college. A similar view will initially pop up, giving the user the
option to select a specific week, and then giving the user a calendar view when a week is
selected. However, this portion of the app will be synced with all other users using a server, so
that events added by one user will show up on all other users phones. These events will be
organized in the portion of the screen allocated for each day by time in a list view format, where
the user can see the basic information about the event (location, time, etc). The user can also
click on the event if more information is required, and a new activity will fire with more
information on the event (similar to DisplayEntryActivity from MyRuns). Furthermore, since this
portion of the app will implement a server, users will be able to view the calendar online and
actually add and delete events from the server web page. This design is similar to the final lab,
but expands upon the design to allow other users to access the server, as well as adds a feature
that allows users to add events on the server, not just delete.
This tab of the application will use activities to hold the buttons, and then an activity to
implement the calendar view. It will then call the database to save and reference that inputted
events. We will also use a server for this portion of the application. The classes that we will
implement for this server will be similar to the final lab, where we will use servlets to register
the phone and then post information via HTML to a webpage. Therefore, we will register the
GCM in the main activity, then use a similar set up of GCMIntentService and ServerUtilities to
handle interacting with the database and the server. We will then use servlets to register the
actual phone to the server, as well as a PostDataServlet that will handle posting the actual data
to the Datastore, so that it can be called upon by the AppEngineServlet and displayed to the
webpage. Finally, we will also implement a SendMessagesServlet so that the calendar can be
modified online and synced with the mobile device.
The friends tab will also communicate with the server, as it must access events added
from another persons phone and display them on their friends mobile devices. Therefore,
when events are added from a friend, or someone the user has selected to follow, the code
will call SendMessagesServlet so that the users phone is notified that an event has been added.
This message will have information specifying it as a friends event, and therefore it will be added
to the second tab.

Below is a picture of how the server and client will communicate.