Ch 2: Getting Started Flashcards

Question

Developing for Mobile and Embedded Devices: Design Tips: Expected Limited Storage Capacity

Answer 1

* Although many devices have quite a bit of storage, lower end devices do not * Most available storage on a device will be used to store photos, music and movies * Users are likely to uninstall apps that take up too much memory * Application install size should be limited * Application should be polite in its use of system resources

Answer 2

* Use Android databases to persist, reuse and share large quantities of data. * Used existing optimized frameworks for Files, Preferences and State information * Clean up after yourself: * caching, pre-fetching, and lazy loading are useful for limiting repetitive network lookups and improving responsiveness * Don't leave files on filesystem or records in a database when they're no longer needed

Answer 3

* Small size and portibility are a challenge for creating good interfaces * Applications should be intuitive and easy to use: * Reduce number of controls * Put most important info front and center * Prioritize Graphical controls * Consider how touch input will affect the interface design * Consider how to support accessibility and non-touch screen devices such as TVs * Create responsive designs and test application on a variety of screens * Ensure UIs scale well

Answer 4

* Internet connectivity is not as fast, reliable, cheap, or readily available as we would like. * It is best to assume a network connection will be slow, intermittent, expensive and unreliable * App should be able to handle losing, or not finding, a data connection * Techniques: * Limit functionality of app * Reduce network lookups to cached bursts when data transfer capabilities are limited

Answer 5

* Battery life is a significant problem * Larger, higher resolution screens and thinner form factors make it worse * Network Data Transfers are one of the most dramatic influencers * Carefully consider if and when you choose to transfer data * Useful APIs for conserving battery life: * Doze * App Standby * Job Scheduler

Answer 6

* Your application is unlikely to be the most important App on a user's phone * Typical Usage Priority: * Communications device * Camera * Music and Video Player * Games * "Useful Stuff" (your app) * People use their phones in many different environments

Answer 7

* Predictable and well behaved * Switch seamlessly from background to foreground * Polite * Present an attractive and intuitive UI * Be responsive

Answer 8

* Performance * Responsiveness * Freshness * Security * Seamlessness * Accessibility

Answer 9

Two Basic Rules: * Don't do work that you don't need to do * Don't allocate memory if you can avoid it System memory is a scarce commodity, take special care to use it efficiently. Think about: * how you use the stack and heap * limiting object creation * being aware of how variable scope affects memory use

Answer 10

* There is a 100-200ms threshold at which users experience a delay * Android Activity Manager and Window Manager enforce a time limit for unresponsive apps * If time limit reached, an "Application Not Responding"(ANR) dialog box is presented to the user to let them close the app. * Android monitors 2 Conditions: * Response to user action * Broadcast Receiver response time

Answer 11

* App must respond to any **user action**, such as a key press or screen touch, within _5 seconds_ * A **Broadcast Receiver** must return from its "***onReceive***" handler within _10 seconds_ If either of these conditions is met, an Application Not Responding (ANR) dialog box will be presented to the user, allowing them to kill the app.

Answer 12

* Move lengthy tasks off of the main UI thread and **run asynchronously** * network or database lookups * Complex Processing( such as calculating game moves) * File I/O * **Show progress** within the UI if there are long-running tasks happening in the background * If initial setup phase is time-consuming: * Render the main view as quickly as possible * Indicate that loading is in progress * Fill in information asynchronously * May also show a splash screen

Answer 13

Ideally, the application would be updated immediately before the user looks at it(constantly). In practice, need to weigh the **update frequency** against its effect on **battery life** and **data usage**. * Consider how often data will be updated * Minimize time users are waiting for refreshes or updates * Limit the effect that background updates have on battery life * The **Job Scheduler** is a useful tool for background updates

Answer 14

_Application access restrictions_ * Each application is "sandboxed" * Access to services and functionality is restricted by requiring applications to declare the permissions they require * Users may accept or reject these requests * An assortment of specialized security tools and implementations

Answer 15

* Make sure application is secure for its own sake * Ensure app does not "leak" permissions, data and hardware access * This could compromise the device or user data

Answer 16

* Be security conscious when **storing or transmitting data** * Take special care not to share or transmit sensitive information, such as * Personally Identifiable Information(**PII**) * Location data * Always perform **input validation** * One of the most common security problems affecting applications * Be cautious when your app may expose access to lower-level hardware to third party apps * Minimize the data used and permissions required by your app

Answer 17

* Consistent user experience: * Applications start, stop, and transition instantly and _without perceptible delays_ or _jarring transitions_ * Speed and responsiveness of mobile device **should not degrade** the longer it is used * Apps should retain the same state when not being used * Should be consistent and intuitive, integrating cleanly with the wider Android environment

Answer 18

* Ensure _Activities are properly suspended_ when not in the foreground * Android sends event handlers for pausing and resuming * Suspend tasks that use processor cycles, network bandwidth, or battery life when app not visible * UI updates and network lookups * _Persist data_ between sessions * _Return to last visible state_ when resumed/restarted * Use _consistent_ and _intuitive_ approach to usability * Use _consistent design language_

Answer 19

* Important not to assume that every user will be exactly like you * Need to consider Internationalization and Usability * Critical for providing accessible support for user with disabilities * May be required to interact with their Android devices in different ways * Android provides some Accessibility features: * text-to-speech * haptic feedback * trackball or D-pad navigation

Answer 20

* Android Virtual Device Manager * Android Emulator * Android SDK Manager * Android Profiler * Lint * Gradle * Vector Asset Studio * APK Analyzer

Answer 21

* Android Debug Bridge (ADB) * Logcat * Android Asset Packaging Tool(AAPT) * SQLite3 * Hprof-conv * Dx * Draw9Patch * Monkey * Monkey Runner * ProGuard

Answer 22

* AVD Manager creates and managers AVDs. * An AVD hosts the Emulator running a particular build of Android. * Each AVD can specify a particular screen size and resolution, memory and storage capacities, and available hardware capabilities * The Emulator is an implementation of the Android Run Time, designed to run within an AVD on your host development computer.

Answer 23

Used to download SDK packages, including: * Android platform SDKs * Support Libraries * Google Play services SDK

Answer 24

A static analysis tool that analyzes your application and its resources to suggest improvements and optimization

Answer 25

An advanced build system and toolkit that manages the compilation, packaging and deployment of an application

Answer 26

Generates bitmap files for each screen density to support older versions of Android that don't support the Android vector drawable format

Answer 27

Provides insight into the composition of your built APK (Package) files

Answer 28

Visualize the behavior and performance of your app. Android Profiler can track memory and CPU use in real time, as well as analyze network traffic.

Answer 29

A client-server application that provides a link between your host computer and virtual and physical Android devices. Allows you to copy files, install compiled application packages(.cpk), and run shell commands

Answer 30

A utility used to view and filter the output of the Android logging system.

Answer 31

Constructs the distributable Android package files (.apk)

Answer 32

A database tool that you can use to access the SQLite database files created and used by Android.

Answer 33

A tool that converts HPROF profiling output files into a standard format to view in your preferred profiling tool.

Answer 34

Converts Java class files (**.class**) into Android (**.dex**) bytecode

Answer 35

A handy utility to simplify the creation of NinePatch graphics using a WYSIWYG(What You See Is What You Get) editor

Answer 36

_Monkey_ Runs within the Android Run Time, generating pseudorandom user and system events. _Monkey Runner_ Provides an API for writing programs to control the VM from outside your application

Answer 37

A tool used to shrink and obfuscate your code by replacing class, variable, and method names with semantically meaningless alternatives. This is useful to make your code more difficult to reverse engineer.

Answer 38

* Allocate enough RAM to the build process * Can modify in the ***gradle.properties*** file * ***org.gradle.jvmargs*** property * Minimum of 2Gb is recommended * If on WIndows, Windows Defender may cause slowdowns * Add project folder to list of Windows Defender exclusions

Answer 39

Instant Run is a feature that significantly reduces build and deploy time for incremental changes. * The first time you build the project, the Gradle build system does a full build * On subsequent builds, Android Studio attempts to improve the build and deploy speed by "swapping" code and resource changes directly into the running debug app process * A small yellow lightning bolt icon indicates that Instant Run is available

Answer 40

* Hot Swap * Incremental code changes are applied and reflected in the app without needing to relaunch the app or even restart the current Activity * Can be used for most simple changes * Warm Swap * Activity needs to be restarted before changes can be seen and used. * Typically required for changes to resources * Cold Swap * App is restarted(but still not reinstalled). * Required for any structural changes such as to inheritance or method signatures

Answer 41

* Quick Search * Autocomplete Selections * Postfix Code Completion * Live Templates

Answer 42

* Open **Action Search** with * **Ctrl + Shift + A** * After opening, can start typing keywords. Any available actions or options containing those words will be available for selection * To seach for files within a project, press **Shift** twice to display the **Search Everywhere** dialog * Wherever there is a list, start typing and the results will be filtered to match

Answer 43

* Normal Autocomplete (by pressing Enter) inserts a new selection in front of it * Pressing **Tab** when selecting an autocomplete option replaces any existing methods and values instead

Answer 44

* Allows you to transform a simple, already typed value or expression into a more complex one * Example: * Can create a for-loop over a List variable by typing ***.fori*** after the variable name * Turn a boolean expression into an if statement by postfixing ***.if*** (or ***.else***) * Can see all the valid postfixes available for a given context using **Cmd + J**

Answer 45

Allows you to use shortcuts that are available as autocomplete options to insert templatized snippets into your code. Dozens of generic and Android-specific Live Templates are available, including a selection of logging shortcuts. You can create your own Live Templates to simplify best-practice patterns or boilerplate within your own code. View or create your own by opening the **settings** **window** and navigating to **Editor -\> Live Templates**

Answer 46

Each virtual device is configured with: * name * physical device type * Android system image * sceen size and resolution * ABI/CPU * Memory and Storage capacities * Hardware capabilities, including * camera * network speeds

Answer 47

* Power button * Volume buttons * Software buttons: * Home * Back * Recents * Rotate display * Take screen shot

Answer 48

* Set GPS location * Simulate GPS track playback * Simulate cellular network connectivity: * Signal strength * Speed * Data connection type * Set Battery status * Simulate incoming phone calls and SMS messages * Simulate fingerprint sensor * Provide mock Sensor data

Answer 49

* Allows you to see "under the hood" * Displays real-time profiling data and graphs for: * CPU * Memory * Network activity * Tracks and displays a timeline for state changes: * Changes in Activity State * User inputs * Screen Rotations

Answer 50

* Inspect CPU activity and method traces: * Time code execution: * Sample based method tracing * Inspect Memory: * Capture heap dumps * View memory allocations * Monitor Traffic * Inspect details of network transmitted files

Answer 51

A client-service application. Lets you connect with an Android device(virtual or actual) * Communications conduit between development hardware and the Android Device or Emulator

Answer 52

A **daemon** running on the device or Emulator A **Service** that runs on the development computer **Client Applications** that communicate with the daemon through the service

Answer 53

* Install applications * Push and Pull files * Run Shell Commands on the target * Change logging settings * Query or modify SQLite databases available on the device

Answer 54

Allows you to better understand the composition of your APK files. Provides an interface to: * View absolute and relative **_size_** of files within the APK * Including .DEX and resource files * View the **_final versions_** of .DEX files * View final version of **AndroidManifest.xml** * Perform a _side-by-side comparison_ of two APKs

Answer 55

* Static Code Analysis tool * Helps identify and correct structural quality issues within your code without running or testing * Checks source code and resource files for potential bugs and optimization improvements, including: * Correctness * Security * Performance * Usability * Accessibility * Internationalization * Problems are highlighted in IDE, with: * description * severity level * suggested remedies, if avalailable

Answer 56

Works from within the ADB shell. Sends a stream of pseudorandom, but repeatable, System Events and UI Events to the application. Can provide some unconventional use of the UI. Particularly useful to stress-test an application, investigating unanticipated edge-cases.

Answer 57

A python scripting API. Lets you send specific UI commands to control an Emulator or device from outside the application. Extremely useful for performing UI Tests, Functional Tests, and Unit Tests in a predictable and repeatable fashion.

Answer 58

A testing framework provided through the Android Testing Support Library. * Provides APIs for writing UI tests to simulate specific user interactions for a specific app. * Detects when main thread is idle * Runs test commands at the appropriate time to improve test reliability * No need to add timing workarounds, such as sleep periods, into test code

Answer 59

Advanced Build System and Toolkit * Integrated into Android Studio * Perform custom build configurations without needing to modify an app's source files * Plug-in based * Capabilities * Configure, extend and customize the build process * Simplify code and resource reuse * Easily create multiple build variants of an application

Answer 60

Security Functionality Implementations Cryptography secure IPC Specialized technology/tools: ASLR NX ProPolice safe\_iop OpenBSD dlmalloc OpenBSD calloc Linux mmap\_min\_addr

Ch 2: Getting Started Flashcards

(84 cards)