CSCE-315: Programming Studio (Spring 2016)

Project 3: Android App Development


Updates will be posted here.

Team configuration

The team configuration will be the same as project 2.

Project Goal

This project is meant to help familiarize you with:

  • the use of XML for data interchange
  • mobile phone application development concepts
  • mobile phone application development tools
  • agile development principles and practice (Test-Driven Development)
  • presenting your work to others

Project Outline

For this project, you will write a mobile phone application (Android) of your own design.

  • Research the Android app scene to find a niche (you can browse the Android Market on the web).
  • Design your own Android app.
  • The app should include the following:
    1. [Mandatory] Graphical user interface, above and beyond the generic interfaces that are available with the example (template) applications when you start a project in Android Studio.
    2. [Mandatory] The use of dynamic graphics (2D or 3D, non-UI, showing a couple of photos is not enough) and/or sound that change based on some kind of real-world (e.g. sound from microphone, video from camera, accelerometer reading, scientific data from web feed, social network feed data, etc.) or synthetic data (fractal, computational geometry, etc.).
    3. [Mandatory] An XML file stored on the SD card or phone memory to keep track of app data. You should define a DTD or XML schema for the app data and use the Android API to validate and manipulate the XML file.
    4. [Section 207] No additional requirements for this project.
    5. [Optional] Communication over the internet or communication with other applications
    6. [Optional] notifications, sound, sensors (GPS, compass, accelerometer, microphone, etc.)
Note that this is a relatively open-ended assignment. Therefore, the first task your team should take on, after organizing the team itself and determining basics such as what features you will try to implement, and how to go about this. Keep your expectations reasonable, and make sure you have plans for what to do, both if you are able to add additional functionality, and if you need to remove functionality. There are a lot of "new" aspects to this project, so you should make sure to keep your expectations reasonable (but not too low).

Test-Driven Development

For this project, you will use the Test-Driven Development approach. You should use a framework that supports unit testing of the functions, classes, etc. you develop, and your development should be focused on a test-driven development approach. That is, you should:
  • First write a test for some functionality of the portion of code you are working on (document these clearly in your development log).
  • Your existing software should, by definition, fail that test.
  • You should write code to address that test.
  • Once tests are passed, you should go back through your code and refactor.
  • Test may be limited to non-UI routines.

Following a TDD approach will take some getting used to. You will be required to check in not only your source code, but also all of the unit tests that you develop. There should also be some evidence of refactoring occurring throughout the process.

You will be required to report on specific examples of where you refactored portions of your code and where the testing system demonstrated usefulness. So, you should note such cases as you develop your code.

See Testing Fundamentals on the Android developer site.


Android SDK provides a rich set of XML-related functionality.
  • You need to use DTD or XML schema to formally define the legal syntax for your XML file.
  • You must validate your XML data file against the DTD or XML schema everytime you use it.

First decide on that kind of app data you will store and make available to the user. XML Resources:


There will be a team grade assigned for the project, and like the first project, the team grade will be apportioned out to the individuals. The rough breakdown of team grade is:

10% TDD methodology -- unit tests for all major functionality, evidence of regression testing and refactoring.

20% App concept and design (concept, features, artistic aspect, etc.).

30% App functionality (must meet all requirements and function properly [GUI, XML use, etc.])

10% data visualization: novel and creative uses of real or synthetic data.

5% XML: design and usage (including validation)

5% Code style (naming, commenting, layout, etc.)

10% Reports and documentation

10% Final presentation


See course web page for deadlines.
  1. Design documents and XML design.
    • The design document requirements are the same as Project 1.
    • Include an illustration that shows a rough transition diagram between different user-interface components of your app: Main screen, buttons, what other screens will be displayed when certain buttons are pressed, menus, response to the "back" button, etc.
    • The XML design can be rough. You should first decide what information to keep track of. You don't need a full DTD or XML schema. An example XML file would be fine. Of course the XML file should reflect what kind of app you will build and what data it is expected to store.
    • Grading:
      • 20%: All four sections
      • 30%: Description and motivation of the app.
      • 30%: State diagram showing activities and transitions
      • 20%: XML design
  2. User interface code.
    • This will include all displays and user interface elements such as buttons, text entry fields, etc. It would be like an hollow shell that provides all major user interaction capability (navigating through different components), without any meat (no actual functionality).
    • Include an updated illustration of your transition diagram.
    • Include a brief report on how you used TDD and include ample screen-shots.
    • Grading:
      • 10%: layout, style, comments
      • 30%: all interface elements implemented
      • 40%: all interface elements function properly
      • 10%: unit testing
      • 10%: development log
  3. Core algorithm implementation.
    • Include main computational functionality of your app, including a fully functioning XML-based app data storage.
    • At this point, it is not required that the functionality is fully integrated with the user interface.
    • Include a brief report on how you used TDD and include ample screen-shots.
    • Grading:
      • 10%: layout, style, comments
      • 30%: all core algorithms implemented
      • 40%: all core algorithms function properly
      • 10%: unit testing
      • 10%: development log
  4. Final version.
    • Fully integrated, polished app.
    • An updated version of your design document.
    • post production notes (changes you had to make to your design and why, difficulties, solutions, lessons learned)
    • individual work load distribution (percentage): must be based on team consensus.
    • Development log.


All teams are required to give a short presentation.
  • 10 minutes per presentation.
  • Team presentation order will be announced later.
  • Presentations are limited to 6 pages including the title page, and should follow the exact format as follows:
    1. Title: project title, team #, list of members (with photos).
    2. Intro: brief intro of the app concept/design
    3. Technical aspects: overall design
    4. Code snippets: major highlights
    5. Screen shots
    6. Conclusion: lessons learned, etc.
  • Since the presentations will be before the final due date, reporting on stuff that are "in progress" will be fine.