Google i o & android q changes 2019

Google IO & Android Q
changes
by
Tim Surkis
Hadas Peled Gil Goldzweig
26/06/2019
Wifi Password: NEXT@tlv4ever

Tim Surkis
www.TSurkis.com
Mobile Software Engineer

> 4,000 members Largest Android Active Community

What Do We Do?
● Fundamentals
● Advanced
● Design
● Hackathon
● Partner Events
● Mentors Program

Hadas Peled
Android Developer
at

Gil Goldzweig
Mobile team lead @ 10bis
Github
Twitter

● Kotlin
● In-App Updates
● Android Q Changes
○ New navigational system
○ Scoped Storage
○ Location
○ Settings Panel
○ Dark Mode
○ Bubble API
○ Sharing
● Jetpack Security
● Benchmark API
● Jetpack Compose
● CameraX
The plan

Kotlin
FIRST
Recommended kotlin course can be found here

in-app
Updates
API 21+
https://developer.android.com/guide/app-bundle/in-app-updates

In-App Update immediate in-app updates

In-App Update implementation
dependencies {
implementation 'com.google.android.play:core:1.5.0'
}

In-App Update implementation
private lateinit var updateManager: AppUpdateManager
override fun onCreate(savedInstanceState: Bundle?) {
updateManager = AppUpdateManagerFactory.create(this)
}

In-App Update immediate updates
override fun onResume() {
updateManager
.appUpdateInfo
.addOnSuccessListener { updateInfo ->
}
}

val updateInProgress =
updateInfo.updateAvailability() ==
UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS
val updateAvailable =
updateInfo.updateAvailability() ==
UpdateAvailability.UPDATE_AVAILABLE &&
updateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)
...
}

val updateInProgress = /*...*/
val updateAvailable = /*...*/
if (updateInProgress || updateAvailable) {
updateManager.startUpdateFlowForResult(
updateInfo,
AppUpdateType.IMMEDIATE,
this,
updateRequestCode)
}
}

private val updateRequestCode: Int = 830
override fun onActivityResult(
requestCode: Int, resultCode: Int, data: Intent?) {
when (requestCode) {
updateRequestCode -> {
}
}
}

updateRequestCode -> {
when (resultCode) {
Activity.RESULT_OK -> {
// Shouldn't occur since the app restarts upon finishing
}
Activity.RESULT_CANCELED -> {
// user canceled or rejected update
}
ActivityResult.RESULT_IN_APP_UPDATE_FAILED -> {
// update failed
}
}
}

In-App Update flexible in-app updates

In-App Update flexible updates
private lateinit var updateManager: AppUpdateManager
private lateinit var installListener: InstallStateUpdatedListener
override fun onCreate(savedInstanceState: Bundle?) {
updateManager = AppUpdateManagerFactory.create(this)
installListener = InstallStateUpdatedListener { installState ->
}
updateManager.registerListener(installListener)
}

In-App Update flexible updates InstallStatus
options
● CANCELED
● DOWNLOADED
● DOWNLOADING
● FAILED
● INSTALLED
● INSTALLING
● PENDING
● REQUIRES_UI_INTENT
● UNKNOWN

override fun onDestroy() {
updateManager.unregisterListener(installListener)
}

private fun requestUpdate() {
updateManager
.appUpdateInfo
}
}

val updateAvailable = updateInfo.updateAvailability() ==
UpdateAvailability.UPDATE_AVAILABLE
val updateAllowed = updateInfo.isUpdateTypeAllowed(
AppUpdateType.FLEXIBLE)
if (updateAvailable && updateAllowed) {
updateInfo,
AppUpdateType.FLEXIBLE,
activity,
updateRequestCode)
}
}

val updateAvailable = updateInfo.updateAvailability() ==
UpdateAvailability.UPDATE_AVAILABLE
val updateAllowed = updateInfo.isUpdateTypeAllowed(
AppUpdateType.FLEXIBLE)
if (updateAvailable && updateAllowed) {
updateInfo,
AppUpdateType.FLEXIBLE,
this,
updateRequestCode)
}
}

protected override fun onResume() {
updateManager
.appUpdateInfo
when (updateInfo.installStatus()) {
InstallStatus.DOWNLOADED ->{
/*do something*/
}
// do something else
}
}
}

protected override fun onResume() {
updateManager
.appUpdateInfo
when (updateInfo.installStatus()) {
InstallStatus.DOWNLOADED -> {
/*do something*/
}
// do something else
}
}
}

Navigation history
API 5.0 Lollipop
API 9.0 Pie
API 10.0 Q*******

new navigation system
Gestures
https://developer.android.com/preview/features/gesturalnav

Gestures
MyAPP
Implications system bounds
Safe Zone

Gestures
MyAPP
getSystemGestureInsets()
getMandatorySystemGestureInsest()
Implications system bounds
??????????
??????????????

View
Gestures Implications override insests
MyAPP
var exclusionRects = listOf(rect1, rect2)
fun onLayout(...) {
setSystemGestureExclusionRects(exclusionRects)
}
fun onDraw(...) {
}
Rect
top
bottom
rightleft

View
Gestures Implications override insests
MyAPP
var exclusionRects = listOf(rect1, rect2, rect3)
fun onLayout(...) {
}
fun onDraw(...) {
}
Rect
top
bottom
rightleft

Gestures Recomendations status and navigation
bars
MyAPP
rootView.systemUiVisibility =
(View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
View.SYSTEM_UI_FLAG_LAYOUT_STABLE)

<style name="AppTheme" parent="...">
<item name="android:navigationBarColor">
@android:color/transparent</item>
<item name="android:statusBarColor">
@android:color/transparent</item>
</style>

Scoped Storage
https://developer.android.com/preview/privacy/scoped-storage

Scoped Storage accessing files
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
Api 29+
android Q and higher
API 28-
android Pie and earlier

Scoped Storage
accessing app files
readwrite
MyApp Accessing App Storage
Photos MediaStore.Images
Videos MediaStore.Video
Audio MediaStore.Audio
* No permission needed!
Other files No access

Scoped Storage
accessing other app files
read
Photos MediaStore.Images
Videos MediaStore.Video
Audio MediaStore.Audio
Other files Storage Access Framework
downloads
DCIM
*android.permission.READ_EXTERNAL_STORAGE required

Scoped Storage
Storage Access Framework
readwrite
documentation: https://developer.android.com/guide/topics/providers/document-provider
Storage Access Framework
98,313 milliseconds
Conventional Android File I/O
3,139 millisecondsSource: https://www.xda-
developers.com/android-q-storage-access-
framework-scoped-storage/

Scoped Storage supporting legacy storage
<manifest>
<application
android:requestLegacyExternalStorage="true">
...
</application>
</manifest>
* Android R will only work with scoped storage

When does my app considered to be in the
foreground?!

Foreground
Activity
Foreground
Service

Pre - Q
<manifest>

<uses-permission
android:name="android.permission.ACCESS_COARSE_LOCATION"/>

<uses-permission
android:name="android.permission.ACCESS_FINE_LOCATION"/>
...
</manifest>

Targets Q
<manifest>

<uses-permission
android:name="android.permission.ACCESS_COARSE_LOCATION"/>

<uses-permission
android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission
android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>
...
</manifest>

Runs on Q -
BUT targets 9 or lower
Q

//Target Q only, request "while-in-use" first
ActivityCompat.requestPermissions(this, arrayOf(
android.Manifest.permission.ACCESS_COARSE_LOCATION // or FINE
), REQUEST_CODE)

//Target Q only, request "while-in-use" first
android.Manifest.permission.ACCESS_COARSE_LOCATION // or FINE
), REQUEST_CODE)
//Request "all-the-time" (only if needed)
android.Manifest.permission.ACCESS_BACKGROUND_LOCATION
), REQUEST_CODE)

if (ContextCompat.checkSelfPermission(this,
android.Manifest.permission.ACCESS_COARSE_LOCATION)
== PackageManager.PERMISSION_GRANTED) {
//Location accessible in foreground
}

android.Manifest.permission.ACCESS_COARSE_LOCATION)
//Location accessible in foreground
}
android.Manifest.permission.ACCESS_BACKGROUND_LOCATION)
//Location accessible in background
}
App permissions best practices

App permissions on OS upgrades
Device upgrade scenarios

Foreground service requires location type
<service
android:name="MyNavigationService"
android:foregroundServiceType="location" ... >
...
</service>

If you didn’t declare type location
● Has permission to location ‘while-in-use’ -
The service has NO permission for location
<service
android:name="MyNavigationService" ... >
</service>

If you didn’t declare type location
● Has permission to location ‘while-in-use’ -
The service has NO permission for location
● Has permission to location ‘all-the-time’ -
The service has permission for location
<service
android:name="MyNavigationService" ... >
</service>

All-the-time permission
+ fine location in background

Examples
● while-in-use: LocationUpdatesForegroundService on GitHub
● all-the-time: LocationUpdatesPendingIntent on GitHub

val panelIntent = Intent(Settings.Panel.settings_panel_type)
startActivityForResult(panelIntent)
Settings panel actions

● ACTION_INTERNET_CONNECTIVITY - Airplane mode, Wifi, Mobile Data.

● ACTION_WIFI - Wifi only.

● ACTION_NFC - All settings related to near-field communication (NFC).

● ACTION_NFC - All settings related to near-field communication (NFC).
● ACTION_VOLUME - Volume settings for all audio streams.

Why?
Environment Battery
Up to 60%
reduction in
power usage

Why?
Environment Battery Accessibility

How to enable
dark theme:
● Settings -> Display ->
Theme

How to enable
dark theme:
Theme
● Quick Settings

How to enable
dark theme:
Theme
● Quick Settings
● Battery Saver (Pixel devices)

Dark theme: app support
Strongly recommended that
apps will support dark theme.

DayNight
● Enables the -night resource qualifier
when in dark theme
● Works back to Android 4.0 (API 14)
● Improved in AppCompat v1.1.0

values/themes.xml
values-night/themes.xml

values/themes.xml
<style name="Theme.AppCompat.Daynight"
parent="Theme.AppCompat.Light">

values/themes.xml
<style name="Theme.AppCompat.Daynight"
parent="Theme.AppCompat.Light">
<style name="Theme.AppCompat.DayNight"
parent="Theme.AppCompat">

ModesDayNight
MODE_NIGHT_YES
//Always use the dark theme

ModesDayNight
MODE_NIGHT_YES
MODE_NIGHT_NO
//Always use the light theme DEFAULT PRE-Q

ModesDayNight
MODE_NIGHT_YES
MODE_NIGHT_NO
MODE_NIGHT_FOLLOW_SYSTEM
//Follows the current system settings DEFAULT ON Q

ModesDayNight
MODE_NIGHT_YES
MODE_NIGHT_NO
MODE_NIGHT_FOLLOW_SYSTEM
//Follows the current system settings DEFAULT ON Q
MODE_NIGHT_AUTO_BATTERY
//Dark when battery saver is enabled API 21+ AND AppCompat-v1.1.0

Support Night ModeDayNight
● AppCompatDelegate.setDefaultNightMode(mode : Int)

● getDelegate().setLocalNightMode(mode : Int)

● getDelegate().setLocalNightMode(mode : Int)
Note: the values are not persisted

Force/Smart Dark
Automatically convert app
to dark theme
implementing dark theme

Seeing strange things?
● xml - android:forceDarkAllowed="false"
● code - setForceDarkAllowed(false)

Force Dark Custom
google sample DayNight

SAWs* are Dangerous
*SYSTEM_ALERT_WINDOW

SAWs* are Dangerous
● Lots of apps are utilizing SAW
to do cool things.

SAWs* are Dangerous
● Lots of apps are utilizing SAW
to do cool things.
● Unfortunately some apps are
utilizing SAW for some
less cool things.

Bubbles
● They float on top of other app
content and follow the user

Bubbles
● Can be expanded to reveal app
functionality and information

Bubbles
● Can be expanded to reveal app
functionality and information
● Built into the notification system

Build a Bubble
● Configure the activity shown in the bubble
● Construct BubbleMetadata
● Add the metadata to your notification and send

Configure the activity shown in the bubble

<activity
android:name=".bubbles.BubbleActivity"
...
/>

Construct BubbleMetadata
val intent = Intent(mContext, MainActivity::class.java)
val bubbleIntent = PendingIntent.getActivity(
mContext, 0 /* requestCode */, intent, 0/* flags*/)

//Metadata to go on the notification
val metadata = Notification.BubbleMetadata.Builder()

//Icon is not displayed in Beta Q
.setIcon(Icon.createWithResource(mContext,
R.drawable.ic_bubble))

//Icon is not displayed in Beta Q
.setIcon(Icon.createWithResource(mContext,
R.drawable.ic_bubble))
.setIntent(bubbleIntent).build()

Add the BubbleMetadata to your
notification and send
var builder = Notification.Builder(mContext, CHANNEL_ID)
.setSmallIcon(R.drawable.notification_icon)
...
.setBubbleMetadata(metadata)

Add the BubbleMetadata to your
notification and send
var builder = Notification.Builder(mContext, CHANNEL_ID)
.setSmallIcon(R.drawable.notification_icon)
...
.setBubbleMetadata(metadata)
//Send the notification
mNotificationManager.notify(BUBBLE_ID, builder.build())

When to use Bubbles?
● Messaging
● Calling
● User initiated

Sharing
● Content preview - supports
images and text

Sharing
images and text
● New sharing shortcut API -
Doesn’t need to start your app

Sharing
images and text
● Copy to clipboard up top

Sharing
images and text
● Copy to clipboard up top
● It’s really really fast

Providing a sharing shortcut
val sic = mutableListOf<ShortcutInfoCompat>()

sic.add( ShortcutInfoCompat.Builder(context, personId)

.setShortLabel("Chet")

.setLongLabel("Chet Haase")

.setPerson(...)//Person can improve ranking

.setIcon(/* Icon */)

.setCategories(category)//required to be a Sharing Shortcut

.setIntent(...).build())

.setIntent(...).build())
ShortcutManagerCompat.addDynamicShortcuts(context, sic)

Adding a rich preview content
var share = Intent(ACTION_SEND)
...

...
//Metadata must be in intent before Intent#crateChooser
share.putExtra(EXTRA_TITLE,"Introducing Android Q Beta")

...
share.clipData = ClipData.newUri(contentResolver,
"thumbnail", myContentProviderUri)
share.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)

...
share.clipData = ClipData.newUri(contentResolver,
"thumbnail", myContentProviderUri)
share.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
share = Intent.createChooser(share,null /* no longer used */)

Jetpack security - key
val masterKey = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC)

Jetpack security - File
val encryptedFile = EncryptedFile.Builder(
).build()

File(context.getFilesDir(), "/your/file"),
).build()

context,
).build()

context,
masterKey,
).build()

context,
masterKey,
EncryptedFileKeyset.FileEncryptionScheme.AES256_GCM_HKDF_4KB
).build()

Jetpack security - Read File
context,
masterKey,
).build()
encryptedFile.openInputStream()

Jetpack security - Write File
context,
masterKey,
).build()
encryptedFile.openInputStrem()
encryptedFile.openOutputStream()

Jetpack security - SharedPreferences

val sharedPreferences = EncryptedSharedPreferences.create(
)

"shareadpreferencesName",
)

masterKey,
)

masterKey,
context,
)

masterKey,
context,
EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
)

Jetpack security
● Currently in alpha
● Min api 23
● More information available here

Benchmark
● Makes it easy to benchmark your code
● Handles warmup and clock stability for you
● Gives you a accurate result
● Runs as instrumented test

What should I benchmark
● RecyclerView scrolling
● Data processing
● Pieces of code that get used repeatedly

Benchmark
@RunWith(AndroidJUnit4::class)
class MyBenchmark() {
}

Benchmark
@get:Rule
val rule = BenchmarkRule()
}

Benchmark
@get:Rule
@Test
fun simpleViewInflate() {
}
}

Benchmark
@get:Rule
@Test
val context = ApplicationProvider.getApplicationContext()
val inflater = LayoutInflater.from(context)
val root = FrameLayout(context)
}
}

Benchmark
@get:Rule
@Test
val context = ApplicationProvider.getApplicationContext()
val inflater = LayoutInflater.from(context)
val root = FrameLayout(context)
rule.measureRepeated {
inflater.inflate(R.layout.test_simple_view, root, false)
}
}
}

Benchmark
/storage/emulated/0/Download/app_id-benchmarkData.json

Benchmark
● Available as part of AndroidX
● You can learn more about Benchmark here

Jetpack compose
UI is defined as a function
● Take data as input
● Emits UI hierarchy when invoked
@Composable
fun Greeting(name: String) {
Text("Hello: $name")
}

@Composable
}
Hello: Gil

What is compose?
● A set of jetpack UI widgets
● A Kotlin compiler plugin
● Unbundled from platform release
● Uses canvas instead of Views
● Fully compatible with your existing app/code

Jetpack compose
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle) {
super.onCreate(savedInstanceState, persistentState)
setContent {
Greeting("Android academy")
}
}
}

Jetpack compose
@Composable
}

Jetpack compose - List
@Composable
fun Greeting(vararg names: String) {
}

@Composable
List {
}
}

@Composable
List {
for (name in names) {
}
}
}

Spinner
Item Clicked
Value changed
OnItemSelected
Item Clicked
OnItemSelected
UI changes Value changed
UI changes

Jetpack compose
fun Counter() {
}

Jetpack compose
@Composable
fun Counter() {
}

Jetpack compose
@Composable
fun Counter() {
val amount
}

Jetpack compose
@Composable
fun Counter() {
val amount = state { 0 }
}

Jetpack compose
@Composable
fun Counter() {
val amount = +state { 0 }
}

Jetpack compose
@Composable
fun Counter() {
Column {
}
}

Jetpack compose
@Composable
fun Counter() {
Column {
Text("Counter demo")
}
}

Jetpack compose
@Composable
fun Counter() {
Column {
Button(text = "Add",
onClick = { amount.value++ })
Button(text = "Subtract",
onClick = { amount.value-- })
}
}

Jetpack compose
@Composable
fun Counter() {
Column {
Button(text = "Add",
onClick = { amount.value++ })
Button(text = "Subtract",
onClick = { amount.value-- })
Text("Clicks: ${amount.value}")
}
}

Jetpack compose
● Currently in pre alpha (Very early stage)
● Available under AOSP and can be used here
● Join the slack channel

Declarative UI Patterns
(Google I/O'19)

Easy….
private val captureCallback = object : CameraCaptureSession.CaptureCallback() {
private fun process(result: CaptureResult) {
when (state) {
STATE_PREVIEW -> Unit // Do nothing when the camera preview is working normally.
STATE_WAITING_LOCK -> capturePicture(result)
STATE_WAITING_PRECAPTURE -> {
// CONTROL_AE_STATE can be null on some devices
val aeState = result.get(CaptureResult.CONTROL_AE_STATE)
if (aeState == null ||
aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE ||
aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) {
state = STATE_WAITING_NON_PRECAPTURE
}
}
STATE_WAITING_NON_PRECAPTURE -> {
if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
state = STATE_PICTURE_TAKEN
captureStillPicture()
}
}
}
}
private fun capturePicture(result: CaptureResult) {
val afState = result.get(CaptureResult.CONTROL_AF_STATE)
if (afState == null) {
} else if (afState == CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED
|| afState == CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED) {
if (aeState == null || aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) {
state = STATE_PICTURE_TAKEN
} else {
runPrecaptureSequence()
}
}
}
override fun onCaptureProgressed(session: CameraCaptureSession,
request: CaptureRequest,
partialResult: CaptureResult) {
process(partialResult)
}
override fun onCaptureCompleted(session: CameraCaptureSession,
result: TotalCaptureResult) {
process(result)
}
}
override fun onCreateView(inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? = inflater.inflate(R.layout.fragment_camera2_basic, container, false)
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
view.findViewById<View>(R.id.picture).setOnClickListener(this)
view.findViewById<View>(R.id.info).setOnClickListener(this)
textureView = view.findViewById(R.id.texture)
}
override fun onActivityCreated(savedInstanceState: Bundle?) {
super.onActivityCreated(savedInstanceState)
file = File(activity.getExternalFilesDir(null), PIC_FILE_NAME)
}
nsor coordinate
* @param maxWidth The maximum width that can be chosen
* @param maxHeight The maximum height that can be chosen
* @param aspectRatio The aspect ratio
* @return The optimal `Size`, or an arbitrary one if none were big enough
*/
@JvmStatic private fun chooseOptimalSize(
choices: Array<Size>,
textureViewWidth: Int,
textureViewHeight: Int,
maxWidth: Int,
maxHeight: Int,
aspectRatio: Size
): Size {
// Collect the supported resolutions that are at least as big as the preview Surface
val bigEnough = ArrayList<Size>()
// Collect the supported resolutions that are smaller than the preview Surface
val notBigEnough = ArrayList<Size>()
val w = aspectRatio.width
val h = aspectRatio.height
for (option in choices) {
if (option.width <= maxWidth && option.height <= maxHeight &&
option.height == option.width * h / w) {
if (option.width >= textureViewWidth && option.height >= textureViewHeight) {
bigEnough.add(option)
} else {
notBigEnough.add(option)
}
}
}
// Pick the smallest of those big enough. If there is no one big enough, pick the
// largest of those not big enough.
if (bigEnough.size > 0) {
return Collections.min(bigEnough, CompareSizesByArea())
} else if (notBigEnough.size > 0) {
return Collections.max(notBigEnough, CompareSizesByArea())
} else {
Log.e(TAG, "Couldn't find any suitable preview size")
return choices[0]
}
}
@JvmStatic fun newInstance(): Camera2BasicFragment = Camera2BasicFragment()
}
}
override fun onResume() {
super.onResume()
startBackgroundThread()
// When the screen is turned off and turned back on, the SurfaceTexture is already
// available, and "onSurfaceTextureAvailable" will not be called. In that case, we can open
// a camera and start preview from here (otherwise, we wait until the surface is ready in
// the SurfaceTextureListener).
if (textureView.isAvailable) {
openCamera(textureView.width, textureView.height)
} else {
textureView.surfaceTextureListener = surfaceTextureListener
}
}
override fun onPause() {
closeCamera()
stopBackgroundThread()
super.onPause()
}
private fun requestCameraPermission() {
if (shouldShowRequestPermissionRationale(Manifest.permission.CAMERA)) {
ConfirmationDialog().show(childFragmentManager, FRAGMENT_DIALOG)
} else {
requestPermissions(arrayOf(Manifest.permission.CAMERA), REQUEST_CAMERA_PERMISSION)
}
}
override fun onRequestPermissionsResult(requestCode: Int,
permissions: Array<String>,
grantResults: IntArray) {
if (requestCode == REQUEST_CAMERA_PERMISSION) {
if (grantResults.size != 1 || grantResults[0] != PackageManager.PERMISSION_GRANTED) {
ErrorDialog.newInstance(getString(R.string.request_permission))
.show(childFragmentManager, FRAGMENT_DIALOG)
}
} else {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
}
}
/**
* Sets up member variables related to camera.
*
* @param width The width of available size for camera preview
* @param height The height of available size for camera preview
*/
private fun setUpCameraOutputs(width: Int, height: Int) {
val manager = activity.getSystemService(Context.CAMERA_SERVICE) as CameraManager
try {
for (cameraId in manager.cameraIdList) {
val characteristics = manager.getCameraCharacteristics(cameraId)
// We don't use a front facing camera in this sample.
val cameraDirection = characteristics.get(CameraCharacteristics.LENS_FACING)
if (cameraDirection != null &&
cameraDirection == CameraCharacteristics.LENS_FACING_FRONT) {
continue
}
val map = characteristics.get(
CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP) ?: continue
// For still image captures, we use the largest available size.
val largest = Collections.max(
Arrays.asList(*map.getOutputSizes(ImageFormat.JPEG)),
CompareSizesByArea())
imageReader = ImageReader.newInstance(largest.width, largest.height,
ImageFormat.JPEG, /*maxImages*/ 2).apply {
setOnImageAvailableListener(onImageAvailableListener, backgroundHandler)
}
// Find out if we need to swap dimension to get the preview size relative to sensor
// coordinate.
val displayRotation = activity.windowManager.defaultDisplay.rotation
sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION)
val swappedDimensions = areDimensionsSwapped(displayRotation)
val displaySize = Point()
activity.windowManager.defaultDisplay.getSize(displaySize)
val rotatedPreviewWidth = if (swappedDimensions) height else width
val rotatedPreviewHeight = if (swappedDimensions) width else height
var maxPreviewWidth = if (swappedDimensions) displaySize.y else displaySize.x
var maxPreviewHeight = if (swappedDimensions) displaySize.x else displaySize.y
if (maxPreviewWidth > MAX_PREVIEW_WIDTH) maxPreviewWidth = MAX_PREVIEW_WIDTH
if (maxPreviewHeight > MAX_PREVIEW_HEIGHT) maxPreviewHeight = MAX_PREVIEW_HEIGHT
// Danger, W.R.! Attempting to use too large a preview size could exceed the camera
// bus' bandwidth limitation, resulting in gorgeous previews but the storage of
// garbage capture data.
previewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture::class.java),
rotatedPreviewWidth, rotatedPreviewHeight,
maxPreviewWidth, maxPreviewHeight,
largest)
// We fit the aspect ratio of TextureView to the size of preview we picked.
if (resources.configuration.orientation == Configuration.ORIENTATION_LANDSCAPE) {
textureView.setAspectRatio(previewSize.width, previewSize.height)
} else {
textureView.setAspectRatio(previewSize.height, previewSize.width)
}
// Check if the flash is supported.
flashSupported =
characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE) == true
val captureBuilder = cameraDevice?.createCaptureRequest(
CameraDevice.TEMPLATE_STILL_CAPTURE)?.apply {
addTarget(imageReader?.surface)
// Sensor orientation is 90 for most devices, or 270 for some devices (eg. Nexus 5X)
// We have to take that into account and rotate JPEG properly.
// For devices with orientation of 90, we return our mapping from ORIENTATIONS.
// For devices with orientation of 270, we need to rotate the JPEG 180 degrees.
set(CaptureRequest.JPEG_ORIENTATION,
(ORIENTATIONS.get(rotation) + sensorOrientation + 270) % 360)
// Use the same AE and AF modes as the preview.
set(CaptureRequest.CONTROL_AF_MODE,
CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE)
}?.also { setAutoFlash(it) }
val captureCallback = object : CameraCaptureSession.CaptureCallback() {
override fun onCaptureCompleted(session: CameraCaptureSession,
result: TotalCaptureResult) {
activity.showToast("Saved: $file")
Log.d(TAG, file.toString())
unlockFocus()
}
}
captureSession?.apply {
stopRepeating()
abortCaptures()
capture(captureBuilder?.build(), captureCallback, null)
}
} catch (e: CameraAccessException) {
Log.e(TAG, e.toString())
}
}
/**
* Unlock the focus. This method should be called when still image capture sequence is
* finished.
*/
private fun unlockFocus() {
try {
// Reset the auto-focus trigger
previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER,
CameraMetadata.CONTROL_AF_TRIGGER_CANCEL)
setAutoFlash(previewRequestBuilder)
captureSession?.capture(previewRequestBuilder.build(), captureCallback,
backgroundHandler)
// After this, the camera will go back to the normal state of preview.
state = STATE_PREVIEW
captureSession?.setRepeatingRequest(previewRequest, captureCallback,
backgroundHandler)
}
}
override fun onClick(view: View) {
when (view.id) {
R.id.picture -> lockFocus()
R.id.info -> {
if (activity != null) {
AlertDialog.Builder(activity)
.setMessage(R.string.intro_message)
.setPositiveButton(android.R.string.ok, null)
.show()
}
}
}
}
private fun setAutoFlash(requestBuilder: CaptureRequest.Builder) {
if (flashSupported) {
requestBuilder.set(CaptureRequest.CONTROL_AE_MODE,
CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH)
}
}
companion object {
/**
* Conversion from screen rotation to JPEG orientation.
*/
private val ORIENTATIONS = SparseIntArray()
private val FRAGMENT_DIALOG = "dialog"
init {
ORIENTATIONS.append(Surface.ROTATION_0, 90)
}
/**
* Tag for the [Log].
*/
private val TAG = "Camera2BasicFragment"
/**
* Camera state: Showing camera preview.
*/
private val STATE_PREVIEW = 0
/**
* Camera state: Waiting for the focus to be locked.
*/
private val STATE_WAITING_LOCK = 1
/**
* Camera state: Waiting for the exposure to be precapture state.
*/
private val STATE_WAITING_PRECAPTURE = 2
/**
* Camera state: Waiting for the exposure state to be something other than precapture.
*/
private val STATE_WAITING_NON_PRECAPTURE = 3
/**
* Camera state: Picture was taken.
*/
private val STATE_PICTURE_TAKEN = 4
/**
* Max preview width that is guaranteed by Camera2 API
*/
private val MAX_PREVIEW_WIDTH = 1920
/**
* Max preview height that is guaranteed by Camera2 API
*/
private val MAX_PREVIEW_HEIGHT = 1080
/**
this.cameraId = cameraId
// We've found a viable camera and finished setting up member variables,
// so we don't need to iterate through other available cameras.
return
}
} catch (e: NullPointerException) {
// Currently an NPE is thrown when the Camera2API is used but not supported on the
// device this code runs.
ErrorDialog.newInstance(getString(R.string.camera_error))
.show(childFragmentManager, FRAGMENT_DIALOG)
}
}
/**
* Determines if the dimensions are swapped given the phone's current rotation.
*
* @param displayRotation The current rotation of the display
*
* @return true if the dimensions are swapped, false otherwise.
*/
private fun areDimensionsSwapped(displayRotation: Int): Boolean {
var swappedDimensions = false
when (displayRotation) {
Surface.ROTATION_0, Surface.ROTATION_180 -> {
if (sensorOrientation == 90 || sensorOrientation == 270) {
swappedDimensions = true
}
}
Surface.ROTATION_90, Surface.ROTATION_270 -> {
if (sensorOrientation == 0 || sensorOrientation == 180) {
swappedDimensions = true
}
}
else -> {
Log.e(TAG, "Display rotation is invalid: $displayRotation")
}
}
return swappedDimensions
}
/**
* Opens the camera specified by [Camera2BasicFragment.cameraId].
*/
private fun openCamera(width: Int, height: Int) {
val permission = ContextCompat.checkSelfPermission(activity, Manifest.permission.CAMERA)
if (permission != PackageManager.PERMISSION_GRANTED) {
requestCameraPermission()
return
}
setUpCameraOutputs(width, height)
configureTransform(width, height)
val manager = activity.getSystemService(Context.CAMERA_SERVICE) as CameraManager
try {
// Wait for camera to open - 2.5 seconds is sufficient
if (!cameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
throw RuntimeException("Time out waiting to lock camera opening.")
}
manager.openCamera(cameraId, stateCallback, backgroundHandler)
} catch (e: InterruptedException) {
throw RuntimeException("Interrupted while trying to lock camera opening.", e)
}
}
/**
* Closes the current [CameraDevice].
*/
private fun closeCamera() {
try {
cameraOpenCloseLock.acquire()
captureSession?.close()
captureSession = null
cameraDevice?.close()
cameraDevice = null
imageReader?.close()
imageReader = null
} catch (e: InterruptedException) {
throw RuntimeException("Interrupted while trying to lock camera closing.", e)
} finally {
cameraOpenCloseLock.release()
}
}
/**
* Starts a background thread and its [Handler].
*/
private fun startBackgroundThread() {
backgroundThread = HandlerThread("CameraBackground").also { it.start() }
backgroundHandler = Handler(backgroundThread?.looper)
}
/**
* Stops the background thread and its [Handler].
hen we get a response in
* [.captureCallback] from both [.lockFocus].
*/
private fun captureStillPicture() {
try {
if (activity == null || cameraDevice == null) return
val rotation = activity.windowManager.defaultDisplay.rotation
// This is the CaptureRequest.Builder that we use to take a picture.
e

Camera
X
● Simplified usage
● Solve many bugs and pain points
● Consistency across devices

Simplified usage
● Preview
● Image analysis
● Image capture

Preview
val previewConfig = PreviewConfig.Builder().build()

Preview
val preview = Preview(previewConfig)

Preview
preview.setOnPreviewOutputUpdateListener {
previewOutput: Preview.PreviewOutput? ->
/* Your code here.
* For example, use previewOutput?.getSurfaceTexture()
* and post to a GL renderer.
*/
}

Preview
preview.setOnPreviewOutputUpdateListener {
previewOutput: Preview.PreviewOutput? ->
/* Your code here.
* For example, use previewOutput?.getSurfaceTexture()
* and post to a GL renderer.
*/
}
CameraX.bindToLifecycle(this as LifecycleOwner, preview)

Image analysis
val imageAnalysisConfig = ImageAnalysisConfig.Builder()

Image analysis
.setTargetResolution(Size(1280, 720))

Image analysis
.build()

Image analysis
.build()
val imageAnalysis = ImageAnalysis(imageAnalysisConfig)

Image analysis
.build()
imageAnalysis.setAnalyzer {
image: ImageProxy, rotationDegrees: Int ->
//insert your analysis code here
}

Image analysis
.build()
imageAnalysis.setAnalyzer {
image: ImageProxy, rotationDegrees: Int ->
//insert your analysis code here
}
CameraX.bindToLifecycle(this as LifecycleOwner, imageAnalysis, preview)

Image capture
val imageCaptureConfig = ImageCaptureConfig.Builder()

Image capture
.setTargetRotation(windowManager.defaultDisplay.rotation)

Image capture
.build()

Image capture
.build()
val imageCapture = ImageCapture(imageCaptureConfig)

Image capture
.build()
val imageCapture = ImageCapture(imageCaptureConfig)
CameraX.bindToLifecycle(this as LifecycleOwner,
imageCapture, imageAnalysis, preview)

Save an Image on user action
fun onClick() {
}

fun onClick() {
val file = File(...)
}

fun onClick() {
imageCapture.takePicture(
)
}

fun onClick() {
imageCapture.takePicture(file,
)
}

fun onClick() {
imageCapture.takePicture(file,
object : ImageCapture.OnImageSavedListener {
override fun onError(error: ImageCapture.UseCaseError,
message: String, exc: Throwable?) {
// insert your code here.
}
override fun onImageSaved(file: File) {
// insert your code here.
}
})
}
Listen to save result

Extensions
Portrait NightBeautyHDR

Extensions
val builder = ImageCaptureConfig.Builder()

Extensions
val bokehImageCapture = BokehImageCaptureExtender.create(builder)

Extensions
val bokehImageCapture = BokehImageCaptureExtender.create(builder)
if (bokehImageCapture.isExtensionAvailable()) {
bokehImageCapture.enableExtension()
}

CameraX
● Available under AndroidX
● You can read more here

Google i o & android q changes 2019

Recommended

Recommended

More Related Content

What's hot

What's hot (6)

Similar to Google i o & android q changes 2019

Similar to Google i o & android q changes 2019 (20)

More from Vitali Pekelis

More from Vitali Pekelis (20)

Recently uploaded

Recently uploaded (20)