| Interaction | - Physical computing<br>- Motor Design Tips<br>- Predicting and testing interactor efficiency<br>- Application design principles<br>- Quantitative Study Design <br>- Data Analysis | - Building pop up menus |
| Interaction | - Physical computing<br>- Motor Design Tips<br>- Predicting and testing interactor efficiency<br>- Application design principles<br>- Quantitative Study Design <br>- Data Analysis | - Building pop up menus |
| Behavior | - Theories of User Behavior<br>- Behavior Change<br>- Machine Learning<br>- Application Security<br>- Heuristic Evaluation | - Implementing a drawing program<br>- Implementing undo/redo feature |
| Behavior | - Theories of User Behavior<br>- Behavior Change<br>- Machine Learning<br>- Application Security<br>- Heuristic Evaluation | - Implementing a drawing program<br>- Implementing undo/redo feature |
## Drawing
How do I draw things on the screen? Do you know how to control what is shown to the user?
- Learn to use drawing abstractions such as [https://developer.android.com/reference/android/graphics/Canvas](Canvas) to programmatically draw on screen and use coordinate transformations to move and scale and orient them. You should be able to place a [https://developer.android.com/reference/android/view/View](View) anywhere onscreen simply by specifying it's upper left x/y coordinates.
- When creating a new component on screen, it is important to properly size it so it is just big enough to fit its content (text, image, etc). To do this, you will Learn to properly set up bounding boxes so Android knows where to place [https://developer.android.com/reference/android/view/View](View)s even during dynamic events such as resizing or animation. The bounding box should be the smallest possible that surrounds the contents
- Nice interactions often incorporate animation. You should be able to set up an animations using timing options such as slow in/slow out.
## Layout
How do I set up an interface so that it looks the way I want and reacts properly to changes in orientation and size? Do you know how to implement a layout, supporting reactivity and so on?
- Be able to visually represent an interface as an [https://developer.android.com/studio/debug/layout-inspector](Interactor Hierarchy) (and vice versa). Given a picture of an interface, can you draw an interactor hierarchy that has all of the necessary components to be properly rendered as that interface? Similarly, given an interactor hierarchy, can you tell what interface it would be rendered as?
- Create reactive layouts that properly position things and handle dynamic events such as resizing or switching from portrait to landscape mode.
Also, given an interactor hierarchy, you should be able to point at which interface images it matches, or edit it to add or remove a visual element.
- Design and implement your own a layout container that can properly lay out any number of child items, to a spec. For example, can you implement a two column scrolling layout, or the facebook newsfeed which dynamically shows things as you scroll? You will need to properly support dynamic addition and removal of child components, as well as properly reacting to changes in scale or orientation.
## Events
Events++ (4 Items)
How do I handle input from the user, both at the application level and within a specific interactor? An advanced but important aspect of android programming is implementing your own interactors. This is strongly tied to event handling because they can only be interactive if you know how to deal with events.
- The most basic and absolutely necessary form of event handling is application callbacks. This is how your application responds when someone presses a button or otherwise interacts, it is the minimum necessary to build a full interface. You should be able to build an application that can respond to callbacks from interactors such as buttons, or custom interactors and properly support separation of concerns between the application and interactors. All information should pass through the callback, and you should be able to update application state in response. You should understand how to use advanced Java programming concepts such as inner classes to support your work.
- If you want to go beyond the default library provided by Android, you need to know how to build an interactor yourself. This involves dealing with lower level events (such as click or keypress events). To do this properly, you need to build an extended finite state machine that knows what state the interactor is in and how to respond to different events depending upon its state.
- Be able to build non-rectangular interactors and other useful interaction techniques. You will learn to use your knowledge of the event handling/bubbling algorithm to properly build non-rectangular interactors, lenses, and other special case input handling.
- Support a class of interaction techninques by building variations on a single interactor that all make use of the same finite state machine controller for their essential behavior. For example, a selection task might be handled as a pie menu or a linear menu. You should be able to accomplish this simply by varying the implementation of essential geometry for your interactor, without needing to modify the state machine underlying your interactor.
## Applications (4 Items)
Learn to build an application that meets basic standards that requiry programmatic support for accessibility, security, and interactivity.
There are interaction programming concepts that need to be considered at the application level. These may not ever show up in a spec, but are still the responsibility of the implementer to consider. Some examples include making your interface secure; supporting undo; and making it accessible. Human behavior is another essential aspect of interface design you must consider. But how does it interact with interface programming? More specifically, this class will cover the following learning goals
- You should be able to implement a simple application from scratch. To meet expectations, this should be complete, meaning it includes an interactor hierarchy, event handling and a responsive layout.
- Fix accessibility problems including adding proper labeling, focus, navigation and contrast. This requires an understanding of how to properly use alt text to describe items on the screen, how to optimize navigation, how to make sure that everything can be accessed by the accessibility tools, that contrast and scaling work properly, and so on and so forth.
- Be able to assess potential security considerations with an app and fix them, based on android's best practices and information found on sites like PrivacyGrade.org
- Properly implement Undo in any interface to help users recover from errors. This requires an understanding of how to capture and store information about changes to an interface over time; and memory management so too much history isn't stored.
## Communication about app concerns
You are unlikely to be building an interface in a vacuum -- you will need to be able to read specs that are provided with you, identify potential problems, and advocate for new directions. These are communication tasks that are critical to success whether you are building interfaces or designing them. We will cover a sample of these in this class including:
- You should be able to read, understand, and apply documentation and specs.
You should be able to use things you haven't see in the library before such as Canvas, Toasts and Floating Action Buttons; Bundler; Activities and the activity life cycle; and XML specifications including inflation. All of these are Android specific concepts that we will not teach in any detail, but will expect you to master. Some examples include Activities, Inflation, Bundles.
- Ethics. Although this is a programming course, unexamined decisions can easily lead to major ethics violations. Thus, it is the job of every employeed/creator to search for possible concerns. You will learn examine an application and identify violations of ethics in the domains of behavior change, machine learning, inclusion/accessibility and/or security. This includes accessibility and security, but also other things such as unexamined biases, e.g. assumptions about skin color.
- Accessibility and Security. Find and describe accessibility/security problems. Part of finding problems is being able to report on them. Such a report might go to someone else who will fix the problems.
- One critical intersection is in the implementation of a study. You need to properly log behavior and analyze that behavior for a study to run. You should be able to properly consent participants, accurately describe the study process, and clearly describe the results of the study, using charts correctly to illustrate them and to draw valid conclusions consistent with your data. Further, based on Fitts law, you should be able to predict which interactions will be slow. This can be helpful in finding small issues such as making an interactor that could have infinite width or height smaller.
