CSCE-315: Programming Studio (Fall 2013)
Project 3: Android App Development
Updates
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
- test-driven development concepts and practices
- 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:
- [Mandatory] Graphical user interface.
- [Mandatory] The use of graphics (2D or 3D, non-UI, dynamic [showing a couple of photos is not enough]) and/or sound.
- [Mandatory] An XML file stored on the SD card 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.
- [Mandatory] Work with some form of scientific data: neuroscience, biology, environmental science, physics, chemistry, astronomy, geological science, etc. Data can be used scientifically, artistically, or for entertainment. Sample data:
- [Optional] Communication over the internet or communication with other
- [Optional] notifications, sound, sensors (GPS, compass, accelerometer, microphone, etc.)
Test-Driven Development
- 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.
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.
There are several test-support tools for the Android platform such as Robotium and Robolectric. You may choose to use any one of these.
XML
- 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:
Grading
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% Scientific data usage: novel and creative uses of scientific data.
5% XML: design and usage (including validation)
5% Code style (naming, commenting, layout, etc.)
10% Reports and documentation
10% Final presentation
For intermediate submissions (except for design docs), the following rubric will be used.
- all deliverables submitted 10%
- all requirements implemented 30% (regardless of function)
- all requirements function properly 30%
- code orgaization and readability 15%
- documentation (input, output, TDD activity log, etc.) 15%
Deliverables
- 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.
- Indicate which scientific data you will use and in what way it will be utilized in your app. Specify the source (URL) and point to the exact data file(s) you will use. Simply displaying data is not enough.
- 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.
- 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.
- 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)
- self-evaluation (briefly discuss how you contributed to the project) and peer evaluation (rate all other team members on the scale of 1 to 5, 5 being best; plus brief comments). Peer evaluation should be submitted individually.
- Development log.
Presentation
- 7 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:
- Title: project title, team #, list of members (with photos).
- Intro: brief intro of the app concept/design
- Technical aspects: overall design
- Code snippets: major highlights
- Screen shots:
- Conclusion: lessons learned, etc.
- Since the presentations will be before the final due date, reporting on stuff that are "in progress" will be fine.