Google I/O: Level up! Build great games for large screens

The case for large screens

In 2022, 52% of players said that they use large screen devices to play games. In addition, we expect revenue from mobile games to grow almost 30% by 2027.

Our research also shows that there is a strong crossover in gamers that play on both mobile phones and large screen devices like PCs. So, by optimizing for more platforms, like large screen devices, you can grow your audience.

Let’s dive into the technical best practices for how to level up your game for large screen devices: input handling, windowing and resizing, and build submission and distribution.

Input handling

As we transition to these large screen surfaces, we’re also transitioning to new modes of input. Adding mouse, keyboard, and gamepad support is often necessary for desktop and laptop form factors. It’s also beneficial for foldables, tablets, and smartphones, too. Mobile players might use a desktop experience mode or enjoy playing docked at a desk. They’ll appreciate the inclusion!

<activity
   android:name=".MyActivity"
   android:configChanges="keyboard|keyboardHidden"
   android:label="@string/app_name">

override fun onConfigurationChanged(newConfig: Configuration) {
   super.onConfigurationChanged(newConfig)
}

override fun onClick(view: View) {
   view.requestPointerCapture()
}

override fun onCreate(savedInstanceState: Bundle) {
   …
   gameView.focusable = View.FOCUSABLE
   gameView.setOnCapturedPointerListener { _, motionEvent ->
      // Use the coordinates from motionEvent to update your view
      // return true if the event is successfully processed.
      true
   }
   …
}

fun onMenuOpen(view: View) {
    view.releasePointerCapture()
}

<users-feature
   android:name="[android.hardware.type.pc](android.hardware.type.pc)"
   android:required="false" />

Windowing and resizing

Expanding your game beyond phones and onto all of our great multi-platform opportunities introduces some additional considerations regarding window management.

On ChromeOS and Google Play Games on PC, your game can run in a windowed mode over a main desktop interface. And on Android tablets and foldables, your game can be run side-by-side with other applications, resized, and even moved between inner and outer displays on foldable devices.

As a baseline, there are a few things you should check to ensure your game is playable across platforms.

For both ChromeOS and Google Play Games on PC, explicitly define the minimum and maximum aspect ratio your game supports. The aspect ratios you define will be respected and the window size locked to the optimal dimensions automatically.

At a minimum, for Google Play Games on PC, you need to at least support 16:9 aspect ratio if your game’s primary orientation is landscape and 9:16 aspect ratio if your game is portrait mode. But, for the best experience, explicitly support 21:9, 16:10, and 3:2 aspect ratios.

On ChromeOS, to provide the best possible experience for players in full-screen, support full-screen immersive mode. This means hiding the system bars, which you can do by setting flags on decorView’s systemUIVisibility field or through the WindowInsetsCompat API, and maximizing the viewable area for your players.

You’ll also want to gracefully handle rotation and resizing configuration events or prevent these from happening when running on ChromeOS devices.

On Android devices with larger screens, running your game in its primary orientation will work exactly the same as on a phone. On certain devices, however, your game can be run in configurations that you might not already handle.

Check the behavior of your game on first launch in different orientations, after rotation, multi-window resizing, and on fold or unfold on new tablets and foldable devices running Android 13. Out of the box, if your game doesn’t support all configurations, we will help by letterboxing your game if necessary and by prompting the player before changing orientation.

To help motivate optimization, note that on some devices when a player moves to an unsupported configuration, they’re given the option to reload the game to best fit the new screen layout.

But, there’s better ways to provide a more seamless experience for your players. Let’s overview how you can level up the large screen experience.

First, declare your main activity as resizeableActivity. This will get you out of compatibility mode. Note that an unset resizeableActivity will default to true.

<application
   android:name="MyGame"
   android:resizableActivity="true" />

Next, declare explicit support for orientation, screenSize, smallestScreenSize, and screenLayout to receive all Large Screen configuration events and avoid Activity recreation.

Now that windowing is in your control, you’ll need to explicitly handle these screen layout configuration events. In your OnConfigurationChanged event handler, you’ll receive a Configuration object containing useful metadata like the current orientation, width, and height. You can also query the WindowManager to check the current screen rotation.

Using this metadata, there are a few different approaches you can take. Ideally, check the new screen dimensions and render to the full window size. This might not work in all cases due to aspect ratio differences. So, alternatively, you could anchor your game UI to the new window size and letterbox your core gameplay content. If there are technical or design limitations that prevent this approach, you could instead do your own in-engine letterboxing to preserve aspect ratio and scale to the best possible dimensions.

override fun onConfigurationChanged(newConfig: Configuration) {
   super.onConfigurationChanged(newConfig)
   val density: Float = resources.displayMetrics.density
   val newScreenWidthPixels =
      (newConfig.screenWidthDp * density).toInt()
   val newScreenHeightPixels =
      (newConfig.screenHeightDp * density).toInt()

   // Configuration.ORIENTATION_PORTRAIT or ORIENTATION_LANDSCAPE
   val newScreenOrientation: Int = newConfig.orientation

   // ROTATION_0, ROTATION_90, ROTATION_180, or ROTATION_279
   val newScreenRotation: Int = windowManager.defaultDisplay.rotation
}

Regardless of the approach you take, test your game in various configurations and ensure there are no cut-off or overlapping in-game UI elements, issues with touch target accessibility, or aspect ratio issues that might cause game content to become stretched, squashed, or otherwise distorted. Also keep in mind that larger screens usually means bigger pixels, because you have the same number of pixels for a much larger area. This can cause pixelation for downsized render buffers or lower resolution assets.

If possible, consider using your highest quality assets on Large Screen devices. If you have a level of quality system implemented, ensure that it accounts for these new devices. If you’re going above and beyond to support full resizability, definitely performance profile your game now that you’re pushing more pixels than you might on phones. Going above and beyond on Large Screen devices is a great way to keep players engaged with your game.

Games like Diablo Immortal and Minecraft implemented great support for game controllers to better immerse their players and support for resizability, allowing their players the ability to resize windows, play in multi-window mode and stream video or communicate with friends without losing their in-game session.

• Diablo Immortal implemented great support for game controllers to better immerse their players and support for resizability, allowing their players the ability to resize windows, play in multi-window mode and stream video or communicate with friends without losing their in-game session.
• Minecraft implemented great support for game controllers to better immerse their players and support for resizability, allowing their players the ability to resize windows, play in multi-window mode and stream video or communicate with friends without losing their in-game session.

When you implement great support for game controllers you can better immerse your players in-game and with support for resizability, you allow your players the ability to resize windows, play games in multi-window mode, and stream video or communicate with friends without losing their in-game session.

There are even more ways to provide great experiences for players on new Large Screen devices.

For example, consider using the Jetpack WindowManager Library⁠ to support new device form factors like foldables. You can query the DeviceState and implement posture handling. One example, would be triggering a virtual control pad on the bottom of a foldable when in the HALF-OPENED state.

fun isTableTopPosture(foldFeature: FoldingFeature?) : Boolean {
   contract { returns(true) implies (foldFeature != null) }
   return foldFeature?.state == FoldingFeature.State.HALF_OPENED &&
   foldFeature.orientation == FoldingFeature.Orientation.HORIZONTAL
}

Read more about Large screens and external displays and Optimizing display size.

Build submission and distribution

To gain the best performance for your games on more large screen devices, we highly recommend you to include x86_64 ABI architecture in your game. X86_64 can bring the best performance on ChromeOS and Google Play Games on PC for your game. Google worked with the game engines and third-party library providers to ensure the support is in place. You should be able to get your x86_64 version of the game with very minimal work. Our collaboration with engines like Unity and Cocos goes beyond just architecture, with improvements in areas like input and windowing support.

Level up with the ChromeOS community

Much of the work we discussed today provides value across large screen opportunities. The improvements you make to optimize for Android tablets and foldables, for example, can also help for ChromeOS and Google Play Games on PC.

To recap, we learned how you can meet the aspect ratio requirements for ChromeOS and Google Play Games on PC and how to provide a great experience on Android tablets and foldables by going above and beyond by supporting full resizability. We also saw how important thoughtful input support for keyboards, mice, and game controllers provides value across large screen devices and can help better immerse your players.

Finally, once you’ve updated your game to support all of these great large screen opportunities, ensure you follow the best practices to build, release, and distribute your game. Support additional APIs, audit for unnecessary feature declarations in your manifest, and streamline your application delivery with App Bundles and Play Asset Delivery.

But there’s still a lot more to learn. Join the ChromeOS Discord channel to engage with the ChromeOS community and start building for ChromeOS.