Screen Size Compatibility for Chromebooks

Resizing Tasks and Windows

Because the activity's window size can change, activities should read the activities' resolution upon start. Activities should react to resolution changes by calling onConfigurationChanged(..). For example, to avoid losing user's work upon maximization, you can do either of the following:

• Handle configuration changes dynamically by adding android:configChanges="screenSize|smallestScreenSize|orientation|screenLayout" to the activity's manifest.
• Restore the previous state by using onSaveInstanceState to make the transition as simple as possible. This is applicable where requesting a restart is the only option.

When looking for the current configuration, always use the configuration from your current activity in getResources().getConfiguration(). Do not use the configuration from your background activity or the one from the system resource. The background activity does not have a size, and the system's configuration may contain multiple windows with conflicting sizes and orientations, so no usable data can be extracted.

Another important consideration is that window content bounds can change. For example, the area within the window that is used by the app can change if the window gets too big to fit the screen. Consider the following guidelines:

• Apps that utilize Android's layout process should automatically be laid out in the available space.
• Native apps should read the available area and monitor size changes to avoid having inaccessible UI elements. Call the following methods to determine the initial available size for this surface:
  • NativeActivity.mLastContent[X/Y/Width/Height]()
  • findViewById(android.R.id.content).get[Width/Height]()
  Continuous monitoring can be done via observer:
  • NativeActivity.onContentRectChangedNative()
  • NativeActivity.onGlobalLayout()
  • Add a listener to view.addOnLayoutChangeListener(findViewById(android.R.id.content))
  If the app is pre-scaling its artwork, it should do this every time the resolution changes.

The system supports free resizing; however, not all apps were written with resizing in mind. Here are some potential issues to look for:

• Handle resizing seamlessly. You can get resized at any point in time because of all kind of reasons. As such it is really important to be able to save and restore your state as well as possible via onSaveInstanceState if a restart becomes necessary. Note that this is also beneficial for Android in general.
• Also make sure that an activity restart is fast by caching objects you have previously allocated. If you do not use the frameworks layout mechanisms—so your app would for example use OpenGL and scale the content, or some other logic kicks in—you should listen to onConfigurationChanged events to avoid activity restarting. Make sure to specify all change events you can handle dynamically.
• If you do not want to get resized you should specify this in your manifest file accordingly.
• It is important to note that the window size is not the screen size and that you probably never need the screen size anyways. To get the window size you should use Activity.getResources().getConfiguration().screenWidth and Activity.getResources().getConfiguration().screenHeight in DP.

To get your current configuration, always use your activity's resource and get the configuration from there, since otherwise you might end up looking at "something," such as the screen properties.

Note that the screen position can change as well. So be sure to always use the system to do window-to-screen space calculations or vice versa.

If you are using Android's view system, your window should get layed out automatically with a size change.

If you do not use the view system and take over the surface, your app must handle size changes on your own.

Native apps should use the mLastContent members—or getting the content view to get the initial size.

Once the app is running it should listen to onContentRectChangedNative or onGlobalLayout events to react to size changes.

Note that with a size change an app should rescale or reload layouts, artwork and update input areas.

Layout

To fill the screen with more information, you can specify different layouts, or you could create the layout dynamically for the requested size. Note that dynamic generation is generally not recommended, but might sometimes be a possibility.

Apps that do not use the layout system should avoid restarting for a configuration change as they might be really expensive. These changes can happen because of obvious reasons like window size changes, but also for non obvious ones—like a device mode conversion. Changing from laptop into tablet would for example report a change that the physical keyboard went away. A restart which makes the user wait or even lose work unexpectedly is not a good experience.

Make sure that your code does not try to access UI elements that have gone away due to a dynamic resize operation.