Android Development Posts

1) What is Biometric? -> Authenticate by using biometric data, and perform cryptographic operations

• Declaring dependencies -> Add the dependencies for the artifacts you need in the build.gradle file for your app or module:

  dependencies {

   // Java language implementation
  implementation "androidx.biometric:biometric:1.1.0"
  
  // Kotlin
  implementation "androidx.biometric:biometric-ktx:1.2.0- 
   alpha05"

  }

2) How to show a biometric authentication dialog?

-> Implementing biometric authentication, such as face recognition or fingerprint recognition, is one way to safeguard sensitive information or premium content within your app. This guide will show you how to support biometric login processes in your app.

• Declare the strong authentication that your app supports. -> To define the types of authentication that your app supports, use the BiometricManager.Authenticators interface. The system lets you declare the following types of authentication:

1. BIOMETRIC_STRONG
2. BIOMETRIC_WEAK
3. DEVICE_CREDENTIAL : (Authentication using a screen lock credential – the user's PIN, pattern, or password.)

• Pass an authentication type or a bitwise mixture of types into the setAllowedAuthenticators() function to define the forms of biometric authentication that your app permits. The code snippet below illustrates how to implement authentication using a Class 3 biometric or a screen lock credential :

   promptInfo = new 
     BiometricPrompt.PromptInfo.Builder()
     .setTitle("Biometric login for my app")
     .setSubtitle("Log in using your biometric 
    credential")
    .setAllowedAuthenticators(BIOMETRIC_STRONG | 
     DEVICE_CREDENTIAL)
   .build();

• Check that biometric authentication is available

   BiometricManager biometricManager = BiometricManager.from(this);

  switch (biometricManager.canAuthenticate(BIOMETRIC_STRONG | DEVICE_CREDENTIAL)) { case BiometricManager.BIOMETRIC_SUCCESS: Log.d("MY_APP_TAG", "App can authenticate using biometrics."); break; case BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE: Log.e("MY_APP_TAG", "No biometric features available on this device."); break; case BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE: Log.e("MY_APP_TAG", "Biometric features are currently unavailable."); break; case BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED: // Prompts the user to create credentials that your app accepts. final Intent enrollIntent = new Intent(Settings.ACTION_BIOMETRIC_ENROLL); enrollIntent.putExtra(Settings.EXTRA_BIOMETRIC_AUTHENTICATORS_ALLOWED, BIOMETRIC_STRONG | DEVICE_CREDENTIAL); startActivityForResult(enrollIntent, REQUEST_CODE); break; }

• Complete the following steps to add biometric authentication to your app using the Biometric library:

1). Include a link to the androidx.biometric library as a dependency in the build.gradle file for your app module.

2). Using the logic in the following code snippet, display the biometric login dialog in the activity or fragment that hosts it:

   private Executor executor;
   private BiometricPrompt biometricPrompt;
  private BiometricPrompt.PromptInfo promptInfo;

@Override
 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_login);
    executor = ContextCompat.getMainExecutor(this);
    biometricPrompt = new 
 BiometricPrompt(MainActivity.this,
        executor, new 
  BiometricPrompt.AuthenticationCallback() {
    @Override
    public void onAuthenticationError(int errorCode,
            @NonNull CharSequence errString) {
        super.onAuthenticationError(errorCode, errString);
        Toast.makeText(getApplicationContext(),
            "Authentication error: " + errString, 
      Toast.LENGTH_SHORT)
            .show();
       }

     @Override
      public void onAuthenticationSucceeded(
            @NonNull BiometricPrompt.AuthenticationResult 
       result) {
        super.onAuthenticationSucceeded(result);
        Toast.makeText(getApplicationContext(),
            "Authentication succeeded!", 
       Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onAuthenticationFailed() {
        super.onAuthenticationFailed();
        Toast.makeText(getApplicationContext(), 
    "Authentication failed",
            Toast.LENGTH_SHORT)
            .show();
       }
     });

     promptInfo = new BiometricPrompt.PromptInfo.Builder()
        .setTitle("Biometric login for my app")
        .setSubtitle("Log in using your biometric 
   credential")
        .setNegativeButtonText("Use account password")
        .build();

   // Prompt appears when user clicks "Log in".
   // Consider integrating with the keystore to unlock 
  cryptographic operations,
   // if needed by your app.
    Button biometricLoginButton = 
  findViewById(R.id.biometric_login);
   biometricLoginButton.setOnClickListener(view -> {
        biometricPrompt.authenticate(promptInfo);
   });
     }

Material design apps use activity transitions to connect different states with motion and transformations. Entry and exit transitions, as well as transitions between shared elements, can be animated.

Android supports these enter and exit transitions

1] Explode :

• Views are moved in or out of the scene's center.

2] Slide :

• Views are moved in or out from a scene's edge.

3] Fade

• Changes the opacity of a view to add or remove it from the scene.

These transitions are also supported on Android

ChangeBounds :

• Makes target views' layout bounds change.

ChangeClipBounds :

• Animates changes made to the clip boundaries of target views.

ChangeTransform :

• Initiates the scale and rotation change of target views.

ChangeImageTransform :

• Images have a change in size and scale as a result of animation.

Check on versions compatibility

// Check if we're running on Android 5.0 or higher
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                // Apply activity transition
            } else {
                // Swap without transition
}

Create custom transitions

• When you define a style that inherits from the material theme, enable window content transitions with the android:windowActivityTransitions attribute.

<style name="BaseAppTheme" 
parent="android:Theme.Material">
      <!-- enable window content transitions -->
      <item name="android:windowActivityTransitions">true</item>
      <!-- specify enter and exit transitions -->
      <item name="android:windowEnterTransition">@transition/explode</item>
      <item name="android:windowExitTransition">@transition/explode</item>

<!-- specify shared element transitions -->
      <item name="android:windowSharedElementEnterTransition">
            @transition/change_image_transform</item>
      <item name="android:windowSharedElementExitTransition">
            @transition/change_image_transform</item>
</style>

This example defines the change_image_transform transition as follows:

<!-- res/transition/change_image_transform.xml -->
<!-- (see also Shared Transitions below) -->
<transitionSet 
       xmlns:android="http://schemas.android.com/apk/res/android">
       <changeImageTransform/>
</transitionSet>

In your code, enable window content transitions by calling Window.requestFeature() :

            // inside your activity (if you did not enable transitions in your theme)
            getWindow().requestFeature(Window.FEATURE_ACTIVITY_TRANSITIONS);

            // set an exit transition
            getWindow().setExitTransition(new Explode());

Use transitions to start an activity

startActivity(intent,ActivityOptions.makeSceneTransitionAnimation(this).toBundle());

Let someone start a new activity with a shared element

To make a screen transition animation between two activities that have a shared element:

            final View imgContainerView = findViewById(R.id.img_container);

            // get the common element for the transition in this activity
            final View androidRobotView = findViewById(R.id.image_small);

            // define a click listener
            imgContainerView.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Intent intent = new Intent(this, Activity2.class);
                    // create the transition animation - the images in the layouts
                    // of both activities are defined with android:transitionName="robot"
                    ActivityOptions options = ActivityOptions
                        .makeSceneTransitionAnimation(this, androidRobotView, "robot");
                    // start the new activity
                    startActivity(intent, options.toBundle());
                }
            });

An activity with multiple elements is an excellent start

            ActivityOptions options = ActivityOptions.makeSceneTransitionAnimation(this,
                    Pair.create(view1, "agreedName1"),
                    Pair.create(view2, "agreedName2"));

We may have used ProGuard in our project when developing Android applications. In this blog, all of the features and how to use ProGuard effectively on Android.

1. What is ProGuard?

ProGuard is a free java tool in Android, which helps us to do the following:

• Shrink(Minify) the code: Remove unused code in the project.
• Obfuscate the code: Rename the names of class, fields, etc.
• Optimize the code: Do things like inlining the functions.

In short, ProGuard has the following impact on our project:

• It reduces the size of the application.
• It removes the unused classes and methods that contribute to the 64K method count limit of an Android application.
• It makes the application difficult to reverse engineer by obfuscating the code.

2. How to use it in our project?

To enable Proguard in your project, in the app's build.gradle add,

buildTypes {
    release {
        minifyEnabled true
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

    }
}

Here, we have minfyEnabled as true. It activates the proguard which takes from the file,

proguard-android.txt

It is under the release block, which means that it will only be applied to the release of the build we generate.

But it can be too much sometimes when the proguard removes too much code and it might break your code for the flow.

So, configuring the code we have to add some custom rules to make sure we remove the set of code from obfuscating. We can fix this by writing out custom rules in our proguard and it will respect while generating the build.

Now, let us see how we can write customs rules in proguard.

1. Keeping class files

Assume we have a data class that is required by some API but that we obfuscate by generating a build. We have a User data class, for example.

data class User(val id: String = "")

and we want not to obfuscate the class which generating build then to ignore it from obfuscating we use @Keep annotation and update the code like,

@Keep
data class User(val id: String = "")

This annotation allows the class to be ignored when minified using proguard. The class and its member functions will be preserved even when not in use.

-keep

to preserve options of class while generating the build. Using -keep over @Keep we get more control over what to preserve and what not to.

2. Keeping a class's members

If we want to keep only the class members and not the entire class while shrinking, we can use,

-keepclassmembers

in the proguard rule file. This will help us to ignore members of a specific class.

Consider the above User class, and we want to preserve all the public methods inside it. We write the rule like,

-keepclassmembers class com.mindorks.sample.User{
    public *;
}

3. Keeping names of the class and members

Let's say we want to keep all of the same class names and members if they are used in the code, i.e. if the class is not used, it will be shrunk by proguard but will not be obfuscated because it has already been shrunk and there is no need for obfuscation.

-keepnames

Practical use of it looks like,

-keepnames class com.mindorks.sample.GlideModule

Here, if the GlideModule would keep all of its names of the class and the member function.

Note:-

As a fragment TAG, do not use something like MainFragment.class.getSimpleName().

While obfuscating, Proguard may assign the same name (A.class) to two different fragments in different packages. Two fragments will have the same TAG in this case. It will result in a bug in your application.

Keep your Proguard mapping file in order to trace back to the original code. You may need to upload it to different locations, such as the PlayStore Console, to see the original stack-trace of the crashes.

The keyboard is one of the basic components of any Android application. Typically, we use the keyboard to take input from the user. Soft keyboards are used in Android applications, and the Android system gives you with a keyboard to receive user input in any EditText or anything similar. Also, the keyboard will be invisible from the screen if the user has given input. So, in this blog, we will learn how to check if keyboard appears in Android app. How can I make this keyboard invisible or turn it off if it is visible?. So, let's get started.

Step 1 − Create a new project in Android Studio, Add the following code to activity_main.xml.

<?xml version = "1.0" encoding = "utf-8"?>
<android.support.constraint.ConstraintLayout
   xmlns:android = "http://schemas.android.com/apk/res/android"
   xmlns:app = "http://schemas.android.com/apk/res-auto"
   xmlns:tools = "http://schemas.android.com/tools"
   android:layout_width = "match_parent"
   android:layout_height = "match_parent"
   android:id = "@+id/main_layout"
   tools:context = ".MainActivity">
   <EditText
      android:id = "@+id/editext"
      android:layout_width = "match_parent"
      android:layout_height = "wrap_content">
   </EditText>
   <Button
      android:id = "@+id/button"
      android:layout_width = "wrap_content"
      android:layout_height = "wrap_content"
      android:text = "Click here to hide"
      app:layout_constraintBottom_toBottomOf = "parent"
      app:layout_constraintLeft_toLeftOf = "parent"
      app:layout_constraintRight_toRightOf = "parent"
      app:layout_constraintTop_toTopOf = "parent" />
</android.support.constraint.ConstraintLayout>

Step 3 − Add the following code to MainActivity.java

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
   ConstraintLayout constraintLayout;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);
      Button button = findViewById(R.id.button);
      EditText editText=findViewById(R.id.editext);
      editText.requestFocus();
      constraintLayout=findViewById(R.id.main_layout);
      constraintLayout.getViewTreeObserver().addOnGlobalLayoutListener(new  ViewTreeObserver.OnGlobalLayoutListener() {
         @Override
         public void onGlobalLayout() {
            Rect r = new Rect();
            constraintLayout.getWindowVisibleDisplayFrame(r);
            int screenHeight = constraintLayout.getRootView().getHeight();
            int keypadHeight = screenHeight - r.bottom;
            if (keypadHeight > screenHeight * 0.15) {
               Toast.makeText(MainActivity.this,"Keyboard is showing",Toast.LENGTH_LONG).show();
            } else {
               Toast.makeText(MainActivity.this,"keyboard closed",Toast.LENGTH_LONG).show();
            }
         }
      });
      button.setOnClickListener(this);
   }

   @Override
   public void onClick(View v) {
      switch (v.getId()) {
         case R.id.button:
         hideSoftkeybard(v);
         break;
      }
   }

   private void hideSoftkeybard(View v) {
      InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
      inputMethodManager.hideSoftInputFromWindow(v.getWindowToken(), 0);
   }
}

Here, we are using hideSoftKeyboard to hide the keyboard if the keyboard is visible on clicking the button.

So, finally, run the application and see the output on your mobile device.

In this blog, we learned how to check if the keyboard is visible or not on the screen. Also, we have if the keyboard is visible then how to close it. That’s it for this blog.

Integrating in-app reviews is very easy. It can be achieved with very minimal code. Let's see how to integrate it.

1. As the In-App Review is a part of the Play core library, we need to add the required dependencies to our app's build.gradle (app level) file,

implementation “com.google.android.play:core:1.8.0”
implementation "com.google.android.material:material:1.3.0-alpha02"

2. First, we need to create the instance of ReviewManager which would help us to start the API. We create the instance using,

ReviewManager manager = ReviewManagerFactory.create(this);

Now, using this manager object, we have to request the flow to launch the In-App review flow.

 ReviewManager manager = ReviewManagerFactory.create(this);
 Task<ReviewInfo> request = manager.requestReviewFlow();
 request.addOnCompleteListener(task -> {
      if (task.isSuccessful()) {
// We can get the ReviewInfo object
      ReviewInfo reviewInfo = task.getResult();
      } else {
// There was some problem, continue regardless of the result.
      }
 });

A complete code is required for the in-app review flow.

MainActivity.java
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import com.google.android.material.dialog.MaterialAlertDialogBuilder;
import com.google.android.play.core.review.ReviewInfo;
import com.google.android.play.core.review.ReviewManager;
import com.google.android.play.core.review.ReviewManagerFactory;
import com.google.android.play.core.tasks.Task;

public class MainActivity extends AppCompatActivity {

   private ReviewManager reviewManager;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       init();
   }

   private void init() {
       reviewManager = ReviewManagerFactory.create(this);
       findViewById(R.id.btn_rate_app).setOnClickListener(view -> showRateApp());
   }

   public void showRateApp() {
       Task<ReviewInfo> request = reviewManager.requestReviewFlow();
       request.addOnCompleteListener(task -> {
           if (task.isSuccessful()) {
               ReviewInfo reviewInfo = task.getResult();
               Task<Void> flow = reviewManager.launchReviewFlow(this, reviewInfo);
               flow.addOnCompleteListener(task1 -> {
               });
           } else {
               showRateAppFallbackDialog();
           }
       });
   }
   private void showRateAppFallbackDialog() {
       new MaterialAlertDialogBuilder(this)
               .setTitle(R.string.rate_app_title)
               .setMessage(R.string.rate_app_message)
               .setPositiveButton(R.string.rate_btn_pos, (dialog, which) -> {

               })
               .setNegativeButton(R.string.rate_btn_neg,
                       (dialog, which) -> {
                       })
               .setNeutralButton(R.string.rate_btn_nut,
                       (dialog, which) -> {
                       })
               .setOnDismissListener(dialog -> {
               })
               .show();
   }
}

How to test the In-App Review?

To check the in-app review flow, you must already have the app approved on Playstore. This does not mean that the application should be available to the public. At the very least, you should have an account ready for internal testing or internal application sharing.

• You can use Internal Test Track to release the app and test the in-app review flow.
• You can use Internal App Sharing to test the in-app review flow.

You can find more information about the test part on the Android Developer page.

Android apps will work in the background (Android Background Service) mode to listen to broadcast messages, push services, and many other features that extend the functionality of the app. Similarly, it comes with job scheduling.

The Android Job Scheduler is a very efficient way of dealing with things. It will provide a wake lock for the app by default, which will provide a guarantee that the device will stay awake until the work is completed. Also, it provides better battery performance, which is the key point in any application.

activity_main.xml

This tutorial deals with the Android JobShedular UI is easy. Just two buttons to start and stop jobscheduler.

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
xmlns:app="http://schemas.android.com/apk/res-auto" 
xmlns:tools="http://schemas.android.com/tools" 
android:layout_width="match_parent" 
android:layout_height="match_parent" 
tools:context=".MainActivity" 
android:orientation="vertical">

<Button 
android:id="@+id/btn_start" 
android:layout_width="match_parent" 
android:layout_height="wrap_content" 
android:text="Start Service"/>; 

<Button 
android:id="@+id/btn_stop" 
android:layout_width="match_parent" 
android:layout_height="wrap_content" 
android:text="Stop Service"/>;

<LinearLayout/>

MyJobScheduler.Java

Add Android JobScheduler, Job Scheduler starts from this class where we can find methods that will start and stop work.

This method deals with the job start where we can also initialize our MyJobExecutor.java class so that we can execute our task as the job starts.

import android.app.job.JobParameters; 
import android.widget.Toast; 

public class MyJobScheduler extends android.app.job.JobService { 

private MyJobExecutor jobExecutor; 

@Override 
public boolean onStartJob(final JobParameters params) { 
jobExecutor = new MyJobExecutor() {

@Override 
protected void onPostExecute(String str) { 
Toast.makeText(MyJobScheduler.this, str, Toast.LENGTH_SHORT).show(); 
jobFinished(params,false); 
} 
}; 
jobExecutor.execute(); 
return true; 
} 

@Override 
public boolean onStopJob(JobParameters params) { 
jobExecutor.cancel(true); 
return false; 
} 

}

This is only part of what’s new, as there are over 100 features that serve app developers to further the entire Android experience. On Google's developer website, you can read about it all.

Media controls

While playing music, you can usually see a notification with music controls if you swipe down the notification drawer. However, now in Android 11, these controls are integrated into the Quick Settings menu. So, if you swipe to the top of the screen and with your Bluetooth and Wi-Fi tiles, you can see the music controls.

You can also choose which device will play music, which is accessible if you have Bluetooth earbuds or speakers connected. Drag the menu further down to see other options, such as the ability to select a song without opening the Music app.

Conversations and Bubbles

Google is finally unveiling its official implementation of the conversation bubbles. If you use Facebook Messenger on Android, you will already be familiar with this feature. This feature enables the conversation to stay in floating bubbles that can be moved around the screen and retrieved from within any application.

Google's own documentation says the section will be on "many phones," not all of them, so some manufacturers may choose to display it differently. In any case, apps will need to be updated to tell Android which notifications are conversations.

Screen recorder

Android finally has in-built screen recording. Screen recording in Android 11 is as easy as adding a quick setting tile and clicking it. Before you start recording, you can choose whether you need to record audio from your microphone or you can choose to show touch on the screen.

The new screen recorder can be accessed by tapping the 'Screen Record' tile in Quick Settings - if you don't see it on your device, press the Edit button in Quick Settings and drag the tile from the hidden options. Once you have it, just tap it to start recording.

Power button menu

Android 11 comes with a new power menu that enables you to quickly access all connected smart devices.

To reach the new menu just long-press the power button and control all connected devices like smart locks and thermostats with one click, without the need to open a lot of applications. This latest addition lets us feel like Google has finally brought smartphones to the smart home.

Notification history

Have you ever wondered which apps send the most push alerts to your phone? Did you accidentally clear the notification and aren't sure if you missed something important? If so, you'll love the new Android 11 Notification History page.

Do you ever refresh an instruction before you get a chance to read it? Right now, you don’t have to think that it was something important. Android 11 has launched Notification History which can be accessed by navigating to Settings> Apps & Notifications> Notifications> Notification History.

Improved 5G Support

Android 11 includes enhanced developer support to help you reap the benefits of faster speeds and 5G networks. You can understand that when a user connects to a 5G network, they get an estimate of the connection bandwidth and check if the connection is metered.

Android 7.0 (API Level 24) provides support for multilingual users, allowing users to select multiple locales in the setting. The locale object budget represents a specific geographic, political, or cultural area.

Operations that require this locale to perform a task are called locale-sensitive and use that locale to generate information for the user.

Step 1: Create A New Project & Create Resource Files

To create a new project in Android Studio.

In this step, we need to create a string resource file for the Gujarati language.Go to app > res > values > right-click > New > Value Resource File and name it as strings.

Now, we have to select the qualifier as a locale from the available list and select the language as Gujarati from the drop-down list. Below is a picture of the steps.

Now, in this resource file, strings.xml(gu-rlN) add the code given below.

<resources>
    <string name="app_name">Change App Language</string>
    <string name="selected_language">ગુજરાતી</string>
    <string name="language">કેમ છો</string>
</resources>

And add this line to the string.xml file, which is the default for English.

<resources>
    <string name="app_name">Change App Language</string>
    <string name="selected_language">English</string>
    <string name="language">How are you</string>
</resources>

Step 2: Create The Layout File For The Application

In this step, we will create a layout for our application. Go to applications> res> Layout> activity_main.xml and add two text views, one for the message and one for the selected language, and an image view for the drop_down icon. Below is the code snippet for the activity_main.xml file.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_margin="48dp"
        android:text="Welcome To InfyOm"
        android:textAlignment="center" />

    <Button
        android:id="@+id/btnGujarati"
        android:layout_margin="16dp"
        android:background="@color/colorPrimary"
        android:textColor="#ffffff"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Gujarati"/>

    <Button
        android:id="@+id/btnEnglish"
        android:layout_margin="16dp"
        android:background="@color/colorPrimary"
        android:textColor="#ffffff"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="English"/>

</LinearLayout>

Step 3: Create LocaleHelper Class

Now, we will create a local helper class. This class has all the functions that will help to change the language at runtime. Go to app > java > package > right-click and create a new Java class and name it LocalHelper. Below is the code for the local helper class.

import android.annotation.TargetApi;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.os.Build;
import android.preference.PreferenceManager;

import java.util.Locale;

public class LocaleHelper {
        private static final String SELECTED_LANGUAGE = "Locale.Helper.Selected.Language";

        // the method is used to set the language at runtime
        public static Context setLocale(Context context, String language) {
            persist(context, language);

            // updating the language for devices above android nougat
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                return updateResources(context, language);
            }
            // for devices having lower version of android os
            return updateResourcesLegacy(context, language);
        }

        private static void persist(Context context, String language) {
            SharedPreferences preferences =                       PreferenceManager.getDefaultSharedPreferences(context);
            SharedPreferences.Editor editor = preferences.edit();
            editor.putString(SELECTED_LANGUAGE, language);
            editor.apply();
        }

        // the method is used update the language of application by creating
        // object of inbuilt Locale class and passing language argument to it
        @TargetApi(Build.VERSION_CODES.N)
        private static Context updateResources(Context context, String language) {
            Locale locale = new Locale(language);
            Locale.setDefault(locale);

            Configuration configuration = context.getResources().getConfiguration();
            configuration.setLocale(locale);
            configuration.setLayoutDirection(locale);

            return context.createConfigurationContext(configuration);
        }

        @SuppressWarnings("deprecation")
        private static Context updateResourcesLegacy(Context context, String language) {
            Locale locale = new Locale(language);
            Locale.setDefault(locale);

            Resources resources = context.getResources();

            Configuration configuration = resources.getConfiguration();
            configuration.locale = locale;
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                configuration.setLayoutDirection(locale);
            }

            resources.updateConfiguration(configuration, resources.getDisplayMetrics());

            return context;
        }
    }

Step 4: Working With the MainActivity.java File

In this step, we will apply Java code to switch between string.xml files to use different languages. First, we will initialize all the views and set click behavior on an Alert dialog box to choose the desired language with the help of the LocalHelper class. Below is the code is given for the MainActivity.java class.

import androidx.appcompat.app.AppCompatActivity;

import android.content.Context;
import android.content.res.Resources;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {
    TextView messageView;
    Button btnGujarati, btnEnglish;
    Context context;
    Resources resources;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        messageView = (TextView) findViewById(R.id.textView);
        btnGujarati = findViewById(R.id.btnGujarati);
        btnEnglish = findViewById(R.id.btnEnglish);

        btnEnglish.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                context = LocaleHelper.setLocale(MainActivity.this, "en");
                resources = context.getResources();
                messageView.setText(resources.getString(R.string.language));
            }
        });

        btnGujarati.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                context = LocaleHelper.setLocale(MainActivity.this, "hi");
                resources = context.getResources();
                messageView.setText(resources.getString(R.string.language));
            }
        });

    }
}