CSCE-315: Programming Studio (Fall 2015)
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
- 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:
- [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 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.
- [Optional] Communication over the internet or communication with other applications
- [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.
See Testing Fundamentals on the Android developer site.
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
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.
- Grading:
- 20%: All four sections
- 30%: Description and motivation of the app.
- 30%: State diagram showing activities and transitions
- 20%: XML design
- 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
- 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
- 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.
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:
- 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.