代写App应用，实现关于Portfolio小程序。
Requirement
For this assignment, you will be completing a series of portfolio tasks in
order to create an application called “Darwin’s Monster Encyclopaedia”. These
portfolio tasks will be developed for both Android & iOS platforms to access
your understanding of mobile development fundamentals. This application will
have a self-contained list of monsters that includes details such as name,
species & attack power. It will support the following features:
- A main launch screen that connects to all other sections
- A create monster screen for the user to create monsters
- A view all / search screen for users to view all monsters and search through
- A detailed information screen. Shows all information of a particular monster. Adhering to design guidelines (Material / Apple)
The assessment will be composed of portfolio tasks released weekly from weeks
1-4. The specific exercises for each week are included in the weekly sections
of Moodle as well as below
Portfolio Exercises
Portfolio Exercise 1: Create A Monster Screen
For the first portfolio exercise, you will be creating the initial foundation
of the Darwin’s
Monster Encyclopaedia along with the Create a Monster screen. You will be
developing this application for both Android & iOS. This exercise will help
familiarise you with the basics of each platform, including developing simple
user interfaces, classes & controllers (known as Activities in Android).
Part 1: Write a Monster class
You are required to develop a simple class called Monster that encapsulates
the attributes and functionality of a Monster.
Your Monster class should include at minimum the following attributes:
- Monster Name
- Age
- Species
- Attack Power
- Health
In addition, the Monster class should include the following functionality: - Ability to access and change attributes
- Summary of the Monster (Includes all above details)
- Generate an attack value (Attack Power + Random Number)
Part 2: Build the Create Monster User Interface (View)
The next step is to design a supporting interface for creating a Monster. This
interface must meet the following requirements:
- Contain five text input fields for the user to enter monster information o Alternatively, number sliders or drop downs could be used (Optional)
- Two buttons called Update and Save which alter the current monster or create a new one
- Ability to display the summary monster information after the Save button has been pressed
- Ability to display feedback stating whether the monster has been saved or updated
You can use the images below as a rough guide as to how you could setup the
user interface.
Part 3: Write the Controller
The final step is to write the Android activity and the iOS View Controller
that will control the interface. These classes should be able to read the data
from the five text fields and modify the text within the Result label.
They will need to invoke methods of a created Monster object and they should
also have methods that run when the two buttons are tapped. When the save
button is tapped, a new Monster Object should be created using values read
from the text fields. The result label should also display Monster summary
information.
When the update button is tapped the current Monster Object should be updated
based on values read from the text fields. The results label should display a
message indicating that the Monster object has been updated.
Portfolio Exercise 2: Construct Application Shell
For the second portfolio exercise, you will be continuing in the creation of
Darwin’s Encyclopaedia. For this task you will be working on expanding the
initial project from part one to include all the required UI screens and the
navigation structure. Upon completion of this task you should have a working
main application UI along with the Create Monster UI created last week.
Part 1: Create & Build the Main UI Screen
For the first step you are required to create the Main UI screen that will be
used to navigate the application. You may design this screen in any way you
see fit. At minimum the screen must have the following:
- A Button to go to the Create Monster Screen
- A Button to go to the Search Monsters Screen
- A Button to go to the View Monster Screen
You will also need to change the starting screen to the Main Screen (As of
last week it is Create Monster). If you are unsure how to design this screen,
you can use the images below as a rough guide
Part 2: Create the Search All Monsters and View Monster Screens
You are required to create two more Views for both the Search All Monsters and
View
Monster screens. Both screens will need a single text view that shows the name
of the current view (For testing purposes).
Part 3: Update Monster class (Android Only)
For the next step you are required to make changes to the Monster class to
ensure it is able to be passed through via intent. This will include the
following steps:
- The class must implement the Parcelable interface
- Must override writeToParcel & describeContents methods
- A Creator constant
- A new Constructor that accepts a Parcel
Part 4: Write the Main UI Controller
The final step for this week is to write the Android activity or iOS View
Controller for controlling the Main UI interface. These classes should react
to button presses and change the active interface as necessary.
Additionally, the View Monster button should create a Monster object when
clicked pass it through to the View Monster UI (Intent and Segue for Android &
iOS respectively). You can leave this as a default or hardcode it yourself. We
will be making use of this next week.
Portfolio Exercise 3: Construct Search & View Screens
For the third portfolio exercise, you will be continuing in the creation of
Darwin’s Encyclopaedia. For this task you will be working on building the
Search Monsters and View Monster screens conforming to the relevant design
standards for Android and iOS (Material Design & Apple Design Principles).
Upon completion of this task you should have a complete working application
with all screens working correctly.
Part 1: Build the Search UI
For the first step you are required to create the Search UI screen that will
be used to display a list of all monsters currently loaded in the program. You
should design this screen with the relevant design guidelines for each
platform (Material Design & Apple Design Principles). At minimum the screen
should have the following:
- A search bar
- A clickable list of Monsters (Clicking on one should take you to the View Monster screen)
- A TextView showing the number of monsters in the list
Each monster in the list should show the following information at minimum: - Monster Name
- Monster Species
If you did not do so last week you should also ensure that clicking the
“Search Monsters” button on the main screen correctly takes you to this
screen.
Part 2: Write the Search UI Controller
You are required to write the UI Controller for the above search screen. This
class should have functionality to search the list of monsters and limit the
monsters shown based on user entered text (Only for names). When the user
clicks on a monster, the class should take the user to the View Monster screen
with full details of the selected monster.
The search functionality should be built using the internal tools for each
device. It should not be manually coded yourself.
Part 3: Build the View Monster UI
For the next step you are required to create the View Monster UI screen. This
screen should contain all information on the provided monster (Passed from
previous screen). You should design this screen with the relevant design
guidelines for each platform (Material Design & Apple Design Principles). At
minimum the screen should have the following:
- Monster Name
- Monster Age
- Monster Species
- Monster Attack Power
- Monster Health
You may also include more information here and make changes to Monster should
you feel it appropriate (These are the minimum requirements)
If you did not do so last week you should ensure that clicking the “View
Monster” button on the main screen takes you to this screen with a default
monster.
Portfolio Exercise 4: Using Persistent Databases
For the final portfolio exercise, you will be making the final touches to
Darwin’s Encyclopaedia. For this task you will be working on creating a
persistent database to store all our Monsters in. The method of storing data
will be different for each of the platforms; with Android using SQLite and iOS
using CoreData. Upon completion of this task you will have finalized
development of Darwin’s Encyclopaedia.
NOTE: Whilst this portfolio task may look shorter than others, the tasks
outlined in this document are immensely time consuming. DO NOT leave this
until late.
Part 1: Update Monster Class
For the first step you are required to make further changes to the Monster
class to allow it to be properly mapped to our persistent storage. For Android
this will involve ensuring proper mapping to the SQLite database and for iOS
this will involve ensuring that the object can be serialized with Core Data.
Part 2: Write the Database Controller
You are required to write a controller class that will handle communications
between our persistent data and our UI screens. This class will need to
contain the following:
- A method for initializing connection to persistent data
- A way of saving a Monster to persistent data
- A way of loading a Monster from persistent data
- A method for closing the connection upon application close
- A method for rolling back changes if an error occurs
Part 3: Update Create Monster Screen
For the next step you are required to make changes to the Create Monster
screen that we first made back in portfolio one. These changes will be within
the Controller and not the actual UI itself.
When the user clicks on the Save Monster button in addition to showing
information on the Monster, it should be added to the persistent database for
later use. Likewise, the update button should make changes to the Monster in
the persistent database if it has already been added (In this case the monster
JUST created. You can expand upon this if you wish).
Part 4: Update Search Monsters Screen
For the final step you are required to make changes to the Search Monsters
screen that was created in Portfolio 2 & 3. Again these changes will be done
solely within the Controller class and not the actual UI design itself.
The list of all monsters should be updated so that it lists all monsters that
currently exist in permanent data. The way you decide to handle this is
entirely up to your discretion. An easy solution would be to load all Monsters
when the Search Screen is opening (Think about issues that may arise from this
however).
Marking Criteria
This assessment is worth 30% of your total marks for this unit. You must
submit an Android and iOS project for each portfolio exercise. Exercises 1 - 3
are worth 20% of the assignment each with Exercise 4 being worth 40%
Each exercise will be marked against the following criteria:
- Implemented Functionality
Your exercise must satisfy the requirements outlined in the lab exercises and
successfully implement all expected functionality without any errors being
raised at runtime. - Coding Quality
You must demonstrate an understanding of good Object-oriented programming
design throughout your coding. Your code should demonstrate OO design
principles such as DRY “Don’t repeat yourself”, high cohesion (well defined
single purpose) and method decomposition. - Interface Design
Each exercise must have a suitable user interface implemented and must adhere
to guidelines outlined in the Material Design specification (Android) or the
iOS Human Interface Guidelines.
In addition to the criteria outlined above, you must also provide code
comments for each exercise. Your comments must outline the logic of the
application and explaining the function of each method written by you.
Failing to comment each exercise appropriately can result in a mark penalty of
50% of the total mark for each exercise that fails to abide by these criteria.
Feedback will be returned within two weeks to help assist you in building your
final application for the semester. Your mark will be reflected in the Moodle
grade book with written feedback.
Submission Requirements
Your solutions will need to be submitted online via Moodle. All exercises need
to be contained within a ZIP archive within an appropriate directory structure
(Android projects in an Android folder, iOS projects in an iOS folder, etc.).
You must ensure that each exercise is able to be compiled and run under the
Android or iOS emulator/simulator.
Failure to submit your assignment on time will result in a 5% penalty for each
day late (including weekends) and may be submitted up to a maximum of 7 days
late. Submissions beyond this deadline may not be accepted without prior
consultation. If you are unable to submit your assignment due to underlying
circumstances, please contact your lecturers immediately.
