Android button auto text size

Kotlin Android Button Text Size

Android Button Text Size

To set Android Button font/text size, we can set android:textSize attribute for Button in layout XML file.

To programmatically set or change Android Button font/text size, we can pass specified size to the method Button.setTextSize(specific_size).

In this tutorial, we will learn how to change the font size of text in Android Button, with the help of example application.

Set Android Button Text Size in Layout File

In this example project, we will change the Button text size in layout file using android:textSize attribute. The following is a step by step process.

Step 1

Open Android Studio and create an Android Project as shown in the following screenshot.

Step 2

Create Button widget in activity_main.xml. Set the text size of Button widget using android:textSize attribute. In the following layout file, we have set the button text size to 24sp.

activity_main.xml

We may keep the MainActivity.kt to the default code.

MainActivity.kt

Step 3

Run this Android Application, and we would get the following output in the screen.

Step 4

You can download this Android project from the following link.

Set Android Button Text Size Programmatically

In this example project, we will change the Button text size programmatically in MainActivity.kt program using Button.setTextSize(unit, size). The following is a step by step process.

Step 1

Open Android Studio and create an Android Project as shown in the following screenshot.

Step 2

Create Button widget in activity_main.xml as shown in the following acitivity_main.xml. Please note that we assigned an id myButton . We shall use this id to get the reference to this Button in MainActivity.kt program.

activity_main.xml

In MainActivity.kt program, we will get the reference to the Button using id, and set its text size to 40sp using Button.setTextSize(int unit, float size) method.

MainActivity.kt

Step 3

Run this Android Application, and we would get the following output in the screen.

Step 4

You can download this Android project from the following link.

Conclusion

In this Kotlin Android Tutorial, we learned how to change the text size of Button widget in Android using Kotlin language via layout file and programmatically.

Источник

Making the most of TextView auto-sizing on Android

Dynamically adjusting the size of text on Android with a simple API

TextView auto-sizing was introduced to the framework with Android 8.0 Oreo (API 26). It offers a simple yet powerful API to solve a particular problem: scaling of text size to fit text bounds.

When is this needed? 🤔

For Android Development, using a fixed textSize , layout_width=»match_parent” and layout_height=»wrap_content” (perhaps inside a scrollable parent) is fairly common practice and suitable for most TextView use cases.

However, consider the case where the width and/or height of the text bounds are fixed and the text needs to adapt to the available space. Examples include a newspaper-style layout, a font selector that needs to show each different font typeface/name on a single-line, etc. The text can’t scroll and we can’t just add a «read more» button. In these scenarios, TextView auto-sizing is precisely what we need.

The basics 🔤

The TextView auto-sizing API is fairly concise. It can be implemented in XML layouts or programmatically. There are three distinct ways of enabling auto-sizing on a TextView , with increasing levels of specificity: Default, Granular and Preset.

At the time of this writing, the chances of anyone having a minSdk of 26 are quite slim. Thankfully, all of the auto-sizing functionality is available in the AndroidX core package (formerly Support Library). The differences to the framework API are minimal:

• Use the app namespace for XML attributes
• Use the functions in TextViewCompat instead those on TextView directly

Note: All of the examples in this post will use the AndroidX implementation.

Before we get going, there are two important points to keep in mind:

• Auto-sizing (as the name would suggest) only adjusts the text size. Other properties (eg. letterSpacing , lineHeight , etc.) are not changed. They do, of course, affect the text layout bounds and thus impact the automatic size chosen for the text.
• It is advised to not use a layout_width or layout_height of «wrap_content» when using TextView auto-sizing, as this may lead to unexpected results. Using a fixed dimension or «match_parent» is fine (or a “0dp” match_constraint if you are using ConstraintLayout ) .

Default auto-sizing 1️⃣

This is the simplest way of enabling TextView auto-sizing. Given the bounds and attributes of a TextView , the text size is adjusted in an attempt to perfectly fit the horizontal and vertical axes.

Note: The granularity dimensions for default auto-sizing are minTextSize = 12sp, maxTextSize = 112sp, and granularity = 1px (see Granular auto-sizing below).

In XML:

Programmatically:

where autoSizeTextType can be:

• TextViewCompat. AUTO_SIZE_TEXT_TYPE_UNIFORM (enabled)
• TextViewCompat. AUTO_SIZE_TEXT_TYPE_NONE (disabled)

Granular auto-sizing 2️⃣

This allows you to define the values used in uniform auto-sizing: the minimum and maximum text sizes as well a dimension for the size of each «step». A «step» is the increase/decrease in size of the text layout bounds. The text size scales uniformly between the minimum and maximum text size after each «step».

In XML:

Programmatically:

where unit is the TypedValue dimension unit of all of the configuration values (eg. TypedValue. COMPLEX_UNIT_SP ).

Preset auto-sizing 3️⃣

This allows you to specify all the possible values used for auto-sizing. The most appropriate text size will be picked from these values to fit the text bounds.

In XML:

Add the preset sizes to res/values/arrays.xml:

Programmatically:

where unit is the TypedValue dimension unit of the preset size values in the array.

Pro-tips and gotchas 🤓

Mixing value types:

You may have noticed that the programmatic versions of granular and preset auto-sizing could be limiting: the TypedValue unit in these functions applies to all of the supplied auto-sizing values. If you want to mix types (eg. PX and SP) then you need to do so in XML.

Auto-sizing to a single line:

You may be required to restrict auto-sized text to a single line. You can set the lines or maxLines TextView layout attributes to «1» (or use the programmatic equivalent). You may also need to adjust the granular autoSizeMinTextSize , as single-line text will be clipped if the minimum text size is reached but the width still exceeds that of the layout bounds.

Performance:

For performance optimization, one might assume that using preset auto-sizing is the best option. In reality, granular text sizes are precomputed given the minimum, maximum and step values and the difference is negligible.

I hope this post has provided some insight into TextView auto-sizing and how best to make use of it. If you have any questions, thoughts or suggestions then I’d love to hear from you!

Источник

Quick Tip: Create Autosizing Text With Android O

The first developer preview of Android O has arrived!

In this series of tips we’ll be exploring some of the new UI features that you can look forward to in the upcoming release of Android O(reo?).

In this first tip, we’ll be getting some hands-on experience with Android O’s new text autosizing feature, which lets you create text that contracts and expands automatically to fit the current layout.

Since this is our first look at Android O here at Envato Tuts+, let’s start by making sure our development environment is Android O-ready.

Set Up the Developer Preview

Currently, you can only access the Android O Developer Preview via the latest canary build of Android Studio.

Canary builds are the bleeding edge of Android Studio, and are typically updated on a weekly basis. While these builds are tested, they’re less stable than the official Android Studio releases, and therefore aren’t recommended for production development.

To download the latest canary build and grab the Android O preview, first launch Android Studio and select Android Studio > Preferences… from the toolbar. Select Appearance & Behavior > System Settings > Updates, and from the dropdown menu select Canary Channel.

Then, click the accompanying Check Now button to download the latest release from the Canary Channel.

Next, restart your IDE, and open the SDK Manager. Making sure the SDK Manager’s SDK Platforms tab is selected, select the Android O Preview component.

Then switch to the SDK Tools tab, and select the following:

• Android SDK Build-Tools 26.0.0 (rc1 or higher)
• Android SDK Platform-Tools 26.0.0 (rc1 or higher)
• Android Emulator 26.0.0
• Support Repository

Click the OK button to download all of these components.

Finally, create a new Android project that targets Android O. For the sake of simplicity, set the project’s minimum SDK to Android 7+ O Preview and then select Empty Activity.

Configure Your Gradle File

Once Android Studio has created your project, open its module-level build.gradle file and change the buildToolsVersion version and the Support Library version to the latest releases:

Throughout this series, we’ll be adding a number of Android O features to this sample app. If you’re going to experience these features in action, then you’ll need to create an AVD that’s running the Android O system image. Launch Android Studio’s AVD Manager, select Create Virtual Device… and then follow the onscreen instructions to create an AVD. You can use the settings of your choice, but when Android Studio prompts you to select your system image, make sure you select O.

Creating More Dynamic Text

One of the new UI features that we can look forward to in Android O is text autosizing. With the addition of a few XML attributes, you can create TextViews that automatically increase and decrease the size of your text so it always fits perfectly within the confines of the TextView.

This automatic scaling can ensure your text remains easy to read across Android’s huge range of different screen sizes and densities. Auto-resizing can also help you avoid strange empty spaces in your layout, or text that gets cut off mid-sentence because you tried to cram too many words into a TextView.

There are two ways that you can implement text autosizing:

• Granularity. This approach allows you to specify a minimum and maximum text size, plus a granularity value, which is how much your text can increase or decrease in size with each “step.” The TextView will then scale your text horizontally and vertically by this incremental value, until it fits the TextView perfectly.
• Preset sizes. This is where you define an array of all the sizes your text can possibly be. Android O will then select the most appropriate size from this array, based on the TextView ’s dimensions.

Whatever method you choose, you’ll always need to add the android:autoSizeText=»uniform» XML attribute to your TextView , so open your layout resource file and add this element now.

Granularity

To implement autosizing using granularity, you’ll need to add the following XML attributes to your TextView :

• autoSizeMinTextSize : The minimum size the TextView can use.
• autoSizeMaxTextSize : The maximum size the TextView can use.
• autoSizeStepGranularity : The increment value. This is 1px by default.

Here, I’m creating a view that can resize its text between 10sp and 100sp , in increments of 2sp :

Preset Sizes

The other option is to create an array of supported text sizes. Android O will then choose the most appropriate value from this list, based on the amount of text it has to display, the TextView ’s dimensions, and the current screen configuration.

If your project doesn’t already contain an arrays.xml file, then you can create one by right-clicking your project’s res/values directory and selecting New > Values Resource File. In the window that appears, give this file the name arrays, and then click OK.

You can then open your new res/values/arrays.xml file and define all the sizes you want your TextView to use.

Finally, reference this array using the autoSizePresetSizes attribute, for example:

Don’t Forget to Test!

Once you’ve added autosizing to a TextView , boot up your Android O AVD and take a look at how your TextView renders on an emulated Android O screen. To check that autosizing is working correctly, update your TextView to display different amounts of text, and then see what impact this has on the final rendered image you see onscreen.

If you do implement autosizing, then it’s important that you test your text views across a range of different screen configurations, as you may need to tweak your minimum and maximum text sizes to ensure your text remains readable across different screens.

Conclusion

In this quick tip, I showed you how to create text that scales automatically. In the next tip, we’ll be looking at how Android O is about to make it much easier to use custom fonts in your Android apps. In the meantime, check out some of our other tutorials:

Источник