代写COMP3059、代做Java语言、代写data、Java编程设计调试

日期：2020-04-13 09:38

COMP3059 - Coursework 1- Fingerpainter

Summary

In this exercise you are required to build an Android painting application. This is an assessed

exercise and will account for 20% of your final module mark. This is an individual coursework,

and your submission must be entirely your own work – please pay particular attention to the

section of this document regarding plagiarism. This document sets out the requirements of

and broad instructions for developing the application.

Your application should be submitted no later than:

? 14 April 2020 @ 16:00

Submissions should be made electronically via Moodle. Standard penalties of 5% per working

day will be applied to late submissions.

Your application should be submitted as a .zip file containing all relevant source code,

configuration and related files, and a compiled .apk file – i.e. the contents of the directory

containing your Android Studio project after a clean rebuild. Do not submit RAR files.

Specification

You should create an application to support a simple drawing / painting task, where the user

can draw onto a canvas using their finger in a variety of colours and with brushes of different

sizes and shapes. The user should either begin with a blank canvas or be able to navigate from

an existing image in the device’s Downloads folder that will be loaded by the application.

Your application must consist of three Activity components:

? An Activity presenting the FingerPainter interface for the user to draw onto

? An Activity allowing the user to select the colour with which to draw

? An Activity allowing the user to select the shape and size of the drawing brush

Furthermore, the application should:

? Integrate with other applications to allow the user to draw on existing images as part

of the drawing task

? Support appropriate lifecycle persistence of Activity UI state

A custom painting View is provided that must form the basis of the application. It is left up to

you to decide how best to design and implement layouts and other views within these

activities.

Your application must be written in Java and make use of the Android SDK. There are no

requirements to target a specific Android API version, however you can assume that your

application will be tested on an emulated device (1080 x 1920 420dpi) running Android API

version 29 (Android 10.0).

You should consider the following when implementing your application:

? Decomposition of the task into discrete Activity components

? Appropriate use of Intents, communication between Activities and appreciation of the

Activity life-cycle

? Appropriate use of Widgets and ViewGroups for layouts that support devices of

differing screen sizes and resolutions

? Your application is expected to have appropriate comments and variable / class

names, so that a reader can easily understand how it works if necessary

Assessment Criteria

As this is a constrained exercise marks are awarded for achieving specific functionality as

follows. For all elements either 0 or full marks are awarded as appropriate. There are no

additional marks available for additional functionality in this exercise:

Marks

The application has an Activity that allows the user to paint onto a blank canvas 4

A second Activity allows the user to select one of at least 5 colours 3

A third Activity allows the user to select the shape and size of the brush 4

The colour choosing Activity is passed and displays the currently chosen colour 2

The brush choosing Activity is passed and displays the current shape and size of

the brush

2

The painting Activity maintains colour and brush state as appropriate

throughout its expected lifecycle

2

The application can be opened from and displays an image from the Downloads

folder on the device for painting

3

Total 20

Plagiarism

N.B. Use of third party assets (tutorials, images, example code, libraries etc.) MUST be

credited and referenced, and you MUST be able to demonstrate that they are available

under a license that allows their reuse.

Making significant use of tutorial code while referencing it is poor academic practice, and

will result in a lower mark that reflects the significance of your own original contribution.

Copying code from other students, from previous students, from any other source, or

soliciting code from online sources and submitting it as your own is plagiarism and will be

penalized as such. FAILING TO ATTRIBUTE a source will result in a mark of zero – and can

potentially result in failure of coursework, module or degree.

All submissions are checked using both plagiarism detection software and manually for

signs of cheating. If you have any doubts, then please ask.

Instructions

Finger Painting

Begin by creating a new application in Android Studio as usual.

Add the custom view FingerPainterView to your app project. This class is available on Moodle.

You can either copy the file directly into your project’s source directory

(projectname/app/src/main/java/…) or create a new FingerPainterView Java class in your

project and copy / paste the code into it, updating the package qualifier accordingly.

Add an instance of the FingerPainterView to the layout of your main activity. You can do this

either statically through its XML layout resource (Containers-> <view> ->FingerPainterView):

Or add it to an appropriate ViewGroup programmatically when the activity is created:

FingerPainterView myFingerPainterView = new FingerPainterView(this);

myFingerPainterView.setId(R.id.myFingerPainterViewId);

myFrameLayout.addView(myFingerPainterView);

Note in either case the FingerPainterView must have an ID, otherwise the view will not receive

the cascaded save state calls (if a view does not have an ID the OS doesn’t know where it

should restore the view to on restore).

If adding the FingerPainterView programmatically (that is, not via the XML layout but at runtime)

you will need to create a static ID resource in res/values/strings.xml and assign it to the

view on creation, otherwise the view will not receive the cascaded save state calls correctly:

<resources>

<string name="app_name">FingerPainter</string>

<item name="myFingerPainterViewId" type="id" />

</resources>

If adding the FingerPainterView via the XML layout you must also remember to specify an ID

to the view as using the attributes panel. You should retrieve and maintain a reference to this

View in the same way as the other views in lab exercise two (findViewById(…) if you’re

instantiating it via the layout resource).

You may find it useful to nest the FingerPainterView inside a FrameView as in the code above,

with its width and height matching that of the parent FrameView.

FingerPainterView

FingerPainterView should automatically create a square paintable canvas that fills the view

space that it is given, and responds to touch (“mouse”) events by drawing lines onto its

internal bitmap. This bitmap is automatically persisted to a cache file.

The class has a few public set / get methods for managing the colour and shape of the brush:

public void setColour(int colour)

…sets the colour of the brush, where colour is of the form 0xAARRGGBB for setting alpha, red,

green and blue values respectively. Alpha should always be 255, i.e. 0xFF. For example, to set

the drawing colour to green:

myFingerPainterView.setColour(0xFF00FF00);

Or:

import android.graphics.Color;

myFingerPainterView.setColour(Color.GREEN);

myFingerPainterView.setColour(Color.parseColor("#FF00FF00"));

To set the shape of the brush:

public void setBrush(Paint.Cap brush)

Where brush is either round or square, defined by the Paint.Cap enum:

import android.graphics.Paint;

Paint.Cap.ROUND

Paint.Cap.SQUARE

To set the width of the brush:

public void setBrushWidth(int width)

Where width is an integer value in pixels.

The equivalent get methods allow you to retrieve the current state of these values. They are

not persisted by the view between instances.

The Task

Create two new activities to allow the user to specify the colour, and size and shape of the

brush respectively.

Each of these activities should be passed the current colour and brush size / shape

respectively – i.e. the colour selection activity should know and display that the user is

currently is painting in red. It is left up to you to create appropriate interfaces to allow the

user to select a colour and brush (they need to input either a SQUARE or ROUND brush, and

a width in pixels) and return these values to the main activity.

Persistence

FingerPainterView takes care of persisting its own internal bitmap state if it happens to be

destroyed – it saves the current picture to a cache file – however the state of other

components, for example the current colour and brush selection are not persisted. You

should handle the relevant activity lifecycle events for your activities to ensure a coherent

user experience if, for example, the device is rotated.

Open

Image

Finger

Painter

Select

Colour

Select

Brush

Implicit Intent

Finally, as in the task diagram above, the user should be able to select an image in another

application and choose to open it with your FingerPainter app. To support this our application

should respond to implicit Intents that conform to something that we can open – in particular

the user attempting to view a file that happens to be an image.

Note that you can load files onto the emulator by downloading via the in-emulator web

browser, pushing files onto the SD card via the Android Device Monitor tool from Android

SDK, or on the command line using adb. Downloaded files are stored in /sdcard/Download/

on the device.

platform-tools$ ./adb push cats.jpg /sdcard/Download/cats.jpg

cats.jpg: 1 file pushed. 21.6 MB/s (251024 bytes in 0.011s)

platform-tools $

The aim here is to, when browsing through their files using the Files application, give the user

the option of opening a file in our FingerPainter as opposed to other applications, such as the

Picture Viewer. We should do this by registering our application as being able to receive the

appropriate intents.

Add a second intent-filter to the main activity in the AndroidManifest – so that the application

can either be started via the launcher or by an intent sent by another application.

This filter should accept intents with an action of android.intent.action.VIEW, category of

android.intent.category.DEFAULT, and data of mimeType image/*

<intent-filter>

<action android:name="android.intent.action.VIEW"/>

<category android:name="android.intent.category.DEFAULT"/>

<data android:scheme="content"

android:mimeType="image/*" />

</intent-filter>

The location of the image to load will be delivered to the main activity via its intent, with the

URI of the image being included in the data field of the intent. FingerPainterView will attempt

to load an image by URI when called from the onCreate method:

myFingerPainter.load(intent.getData());

If successful, you can test this by opening an image from the Downloads app on the device,

which should now give you the option of your app to open the image with, as well as other

installed applications.

If you are targeting Android 10 (or Q, or SDK version 29), the FingerpainterView may cause a

compilation error as below:

The quick fix for this is to change the compileSdkVersion in the application's build.gradle file

from 29 to 28. This will then prompt Android Studio to ask you to sync the project, which will

fix the error.

This error arises as bitmap.compress is now considered a function that "takes some time" and

so should not be permitted to be called from the UI thread. The implication is that bitmaps

should not be saved via onSaveInstanceState, but unfortunately this is how FingerpainterView

is naively constructed.

The preference for "larger" transient instance state is to persist this slightly differently using

a ViewModel. Here the simplest refactoring is for the FingerPainterView bitmap to be copied

into a ViewModel onSaveInstanceState.

Note: there is no expectation that you do this for the coursework.