Jetpack WindowManager 1.4 is steady

Posted by Xiaodao Wu – Developer Relations Engineer

Jetpack WindowManager retains getting higher. WindowManager provides you instruments to construct adaptive apps that work seamlessly throughout every kind of huge display screen gadgets. Model 1.4, which is steady now, introduces new options that make multi-window experiences much more highly effective and versatile. Whereas Jetpack Compose remains to be the easiest way to create app layouts for various display screen sizes, 1.4 makes some huge enhancements to exercise embedding, together with exercise stack spinning, pane growth, and dialog full-screen dim. Multi-activity apps can simply make the most of all these nice options.

WindowManager 1.4 introduces a variety of enhancements. Listed here are a number of the highlights.

WindowSizeClass

We’ve up to date the WindowSizeClass API to assist customized values. We modified the API form to make it simple and extensible to assist customized values and add new values sooner or later. The excessive degree adjustments are as follows:

• Opened the constructor to absorb minWidthDp and minHeightDp parameters so you’ll be able to create your individual window measurement lessons
• Added comfort strategies for checking breakpoint validity
• Deprecated WindowWidthSizeClass and WindowHeightSizeClass in favor of WindowSizeClass#isWidthAtLeastBreakpoint() and WindowSizeClass#isHeightAtLeastBreakpoint() respectively

Right here’s a migration instance:

// previous 

val sizeClass = WindowSizeClass.compute(widthDp, heightDp)
when (sizeClass.widthSizeClass) {
  COMPACT -> doCompact()
  MEDIUM -> doMedium()
  EXPANDED -> doExpanded()
  else -> doDefault()
}

// new
val sizeClass = WindowSizeClass.BREAKPOINTS_V1
                               .computeWindowSizeClass(widthDp, heightDp)

when {
  sizeClass.isWidthAtLeastBreakpoint(WIDTH_DP_EXPANDED_LOWER_BOUND) -> {
    doExpanded()
  }
  sizeClass.isWidthAtLeastBreakpoint(WIDTH_DP_MEDIUM_LOWER_BOUND) -> {
    doMedium()
  }
  else -> {
    doCompact()
  }
}

Some issues to notice within the new API:

• The order of the when branches ought to go from largest to smallest to assist customized values from builders or new values sooner or later
• The default department must be handled because the smallest window measurement class

Exercise embedding

Exercise stack pinning

Exercise stack pinning supplies a solution to preserve an exercise stack at all times on display screen, it doesn’t matter what else is occurring in your app. This new characteristic helps you to pin an exercise stack to a particular window, so the highest exercise stays seen even when the consumer navigates to different components of the app in a unique window. That is good for issues like dwell chats or video gamers that you just wish to carry on display screen whereas customers discover different content material.

personal enjoyable pinActivityStackExample(taskId: Int) {
 val splitAttributes: SplitAttributes = SplitAttributes.Builder()
   .setSplitType(SplitAttributes.SplitType.ratio(0.66f))
   .setLayoutDirection(SplitAttributes.LayoutDirection.LEFT_TO_RIGHT)
   .construct()

 val pinSplitRule = SplitPinRule.Builder()
   .setDefaultSplitAttributes(splitAttributes)
   .construct()

 SplitController.getInstance(applicationContext).pinTopActivityStack(taskId, pinSplitRule)
}

Pane growth

The brand new pane growth characteristic, often known as interactive divider, helps you to create a visible separation between two actions in split-screen mode. You can also make the pane divider draggable so customers can resize the panes – and the actions within the panes – on the fly. This provides customers management over how they wish to view the app’s content material.

val splitAttributesBuilder: SplitAttributes.Builder = SplitAttributes.Builder()
   .setSplitType(SplitAttributes.SplitType.ratio(0.33f))
   .setLayoutDirection(SplitAttributes.LayoutDirection.LEFT_TO_RIGHT)

if (WindowSdkExtensions.getInstance().extensionVersion >= 6) {
   splitAttributesBuilder.setDividerAttributes(
       DividerAttributes.DraggableDividerAttributes.Builder()
           .setColor(getColor(context, R.colour.divider_color))
           .setWidthDp(4)
           .setDragRange(
               DividerAttributes.DragRange.DRAG_RANGE_SYSTEM_DEFAULT)
           .construct()
   )
}
val splitAttributes: SplitAttributes = splitAttributesBuilder.construct()

Dialog full-screen dim

WindowManager 1.4 provides you extra management over how dialogs dim the background. With dialog full-screen dim, you’ll be able to select to dim simply the container the place the dialog seems or the complete job window for a unified UI expertise. The whole app window dims by default when a dialog opens (see EmbeddingConfiguration.DimAreaBehavior.ON_TASK).To dim solely the container of the exercise that opened the dialog, use EmbeddingConfiguration.DimAreaBehavior.ON_ACTIVITY_STACK. This provides you extra flexibility in designing dialogs and makes for a smoother, extra coherent consumer expertise. Temu is among the many first builders to combine this characteristic, the full-screen dialog dim has diminished display screen invalid touches by about 5%.

Enhanced posture assist

WindowManager 1.4 makes constructing apps that work flawlessly on foldables easy by offering extra details about the bodily capabilities of the machine. The brand new WindowInfoTracker#supportedPostures API lets you recognize if a tool helps tabletop mode, so you’ll be able to optimize your app’s format and options accordingly.

val currentSdkVersion = WindowSdkExtensions.getInstance().extensionVersion
val message =
if (currentSdkVersion >= 6) {
  val supportedPostures = WindowInfoTracker.getOrCreate(LocalContext.present).supportedPostures
  buildString {
    append(supportedPostures.isNotEmpty())
    if (supportedPostures.isNotEmpty()) {
      append(" ")
      append(
      supportedPostures.joinToString(
      separator = ",", prefix = "(", postfix = ")"))
    }
  }
} else {
  "N/A (WindowSDK model 6 is required, present model is $currentSdkVersion)"
}

Different API adjustments

WindowManager 1.4 contains a number of API adjustments and additions to assist the brand new options. Notable adjustments embrace:

• Steady and now not experimental APIs:
• ActivityEmbeddingController#invalidateVisibleActivityStacks
• ActivityEmbeddingController#getActivityStack
• SplitController#updateSplitAttributes

• API added to set exercise embedding animation background:
• SplitAttributes.Builder#setAnimationParams

• API to get up to date WindowMetrics info:
• ActivityEmbeddingController#embeddedActivityWindowInfo

• API to complete all actions in an exercise stack:
• ActivityEmbeddingController#finishActivityStack

How one can get began

To start out utilizing Jetpack WindowManager 1.4 in your Android tasks, replace your app dependencies in construct.gradle.kts to the most recent steady model:

dependencies {
    implementation("androidx.window:window:1.4.0-rc01")
    ...  
    // or, in the event you're utilizing the WindowManager testing library:
    testImplementation("androidx.window:window-testing:1.4.0-rc01")
}

Pleased coding!