Category: Mobile Development

Hello I want to send multiple values from a to an api function.

on the db i store the values in text format. The value that is stored is array

on the Swal alert, I am getting [object object] but i want to get each value e.g. Painting or Graphic Design.

Here is my code so far.

html

<ion-item>
  <ion-label>Painting</ion-label>
  <ion-toggle color="gold" [(ngModel)]="creative.Painting" (click)="creativeInterest(creative)"></ion-toggle>
</ion-item>

<ion-item>
  <ion-label>Graphic Design</ion-label>
  <ion-toggle color="tertiary" [(ngModel)]="creative.Graphic Design" (click)="creativeInterest(creative)"></ion-toggle>
</ion-item>

.ts

   export class CreativeSettingsPage implements OnInit {
    creative: any = {};
    userDetails: any = {};
    constructor(
      public userData: UserData
  ) {
    this.userDetails = this.userData.getUserData();
   }

  ngOnInit() {
  }

  creativeInterest(creative:string)
  {
    this.userData.creativeSettings(this.userDetails.uid, creative).pipe(
      map((data: any) => {
        if (data.success) {
          Swal.fire({
            icon: 'success',
            title: creative,
            showConfirmButton: false,
            backdrop: false,
            timer: 2500
          })
        }
      })
    ).subscribe()
  }

user-data.ts

    creativeSettings(uid: number, creative:any) {
        const url = this.appData.getApiUrl() + 'creativeSettings';
        const data = this.jsonToURLEncoded({
            uid: uid,
            creative: creative
        });
        return this.http.post(url, data, { headers: this.options });
    }

php

function creativeSettings()
{
$request = \Slim\Slim::getInstance()->request();
$response['success'] = true; // 1 true if not errors OK NOTHING

$uid = $request->post('uid');
$creative_interests =  $request->post('creative');

$db = getDB();
$sql = "UPDATE users SET creative_interests = :creative_interests WHERE uid = :uid";
$stmt = $db->prepare($sql);
$stmt->bindParam("uid", $uid);
$stmt->bindParam("creative_interests", $creative_interests);
$stmt->execute();
$db = null;

echo json_encode($response);

}

The Storage Access Framework (SAF) provides a great way to access files exposed by other applications via their own DocumentProviders. In this tutorial, we will learn how to use the SAF in our App.

At the end of the tutorial, you would have learned:

1. How to open documents via the Storage Access Framework.

Android Studio. The version used in this tutorial is Arctic Fox 2020.3.1 Patch 4.

1. Intermediate Android.
2. ActivityResult API.
3. Intents

To follow along with the tutorial, perform the steps below:

1. You are commended to use a test device or AVD image with the Google Play Store pre-installed.

2. Install Adobe Acrobat Reader: Edit PDF

3. Using the default Chrome browser on your AVD, download a sample PDF file from this projects Github repository here. This ensures that the downloaded file will be written to the MediaStore.Downloads table.

4. Create a new Android project with the default Empty Activity.

5. Delete the default Hello World! TextView.

6. Add a new Button to ConstraintView.

7. Constraint the Button to the center of the screen.

8. Extract the android:text of the Button to strings.xml with the value of Open PDF.

9. Your acitivty_main.xml file should now look similar to this.

    <?xml version="1.0" encoding="utf-8"?>
    <androidx.constraintlayout.widget.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"
       tools:context=".MainActivity">
   
       <Button
           android:id="@+id/button"
           android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@string/open_pdf"
           app:layout_constraintBottom_toBottomOf="parent"
           app:layout_constraintEnd_toEndOf="parent"
           app:layout_constraintStart_toStartOf="parent"
           app:layout_constraintTop_toTopOf="parent" />
    </androidx.constraintlayout.widget.ConstraintLayout>

Our project is quite simple. It only has a single Button View. When completed, we expect our App to successfully provide the workflow below:

1. The end user taps on the button.
2. Android provides the user with a Picker to select PDF files.
3. The end user selects a PDF file in the Picker.
4. Our App starts an implicit Intent to let Android decide which App to handle the Intent.
5. The user selects the Adobe PDF reader to read the PDF file.
6. Android opens the Adobe PDF reader, passing in the URI for the file selected previously at step 3.
7. The user can now view the PDF file.

The SAF has three components:

1. Document provider: a class that implements DocumentsProvider. This class can provide read and write access to files either locally or cloud-based. It must also include the proper <provider> tag in its manifest. Android already provides some default DocumentsProvider for us to use, so we do not have to implement them by ourselves in this tutorial. When the file Picker is shown, all registered DocumentProviders will be listed. In the screenshot below, each of the listings in red is a DocumentProvider.
   
2. Client: an App that will make use of the Document Provider via the intent actions ACTION_CREATE_DOCUMENT, ACTION_OPEN_DOCUMENT, or ACTION_OPEN_DOCUMENT_TREE. For this tutorial, we will not use Intents and these intent actions directly, instead we will leverage the premade AcitvityResultContract implementations from ActivityResultContracts.
3. Picker: A file Picker UI provided by the system, so we do not have to implement it by ourselves either.

With the basic concepts out of the way, it is time to write some code. The first thing that we would need to do is to launch the file Picker with our App.

1. Append to MainActivity#onCreate with the code below to create an ActivityResultLauncher and an empty callback. Notice that we used the premade ActivityResultContract implementation ActivityResultContracts.OpenDocument here.

    val openPdfLauncher = registerForActivityResult(OpenDocument()) { uri ->
   
    }

2. Retrieve the Button object.

    //Gets a reference to the Button object
    val button = findViewById<Button>(R.id.button)

3. Binds the Buttons onClickListener to launch(). You can pass a String array to filter out files by MIME types. The first two commented out array declarations are just examples to give you some ideas.

    //Binds button to start the file Picker
    button.setOnClickListener {
       //val input = emptyArray<String>() //this will match nothing.
       //val input = arrayOf("text/plain") //if you want to filter .txt files
       val input = arrayOf("application/pdf")
       openPdfLauncher.launch(input)
    }

The code provided so far will only launch the file Picker and then return to our App, doing nothing else. To read the PDF file with an external App, add the code below inside of the openPdfLauncher callback. Notice my comment regarding the use of the FLAG_GRANT_READ_URI_PERMISSION below, so you should be careful when passing the permission via an implicit intent.

//Creates the Intent object, specifying the uri and mime type
val openPdfIntent = Intent().apply {
   action = Intent.ACTION_VIEW
   type = "application/pdf"
   data = uri
   //grant the handler permission to read the Uri.
   //Should sanitize to avoid leaking sensitive user information.
   flags = Intent.FLAG_GRANT_READ_URI_PERMISSION
}

//Asks the system to start another activity that can handle Intent
startActivity(openPdfIntent)

We are now ready to run the App. You should be able to replicate the expected user flow like in the animation below.

MainActivity.kt

package com.example.daniwebandroidstorageaccessframework

import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import androidx.activity.result.contract.ActivityResultContracts.OpenDocument

class MainActivity : AppCompatActivity() {
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)

       val openPdfLauncher = registerForActivityResult(OpenDocument()) { uri ->


           //Creates the Intent object, specifying the uri and mime type
           val openPdfIntent = Intent().apply {
               action = Intent.ACTION_VIEW
               type = "application/pdf"
               data = uri
               //grant the handler permission to read the Uri.
               //Should sanitize to avoid leaking sensitive user information.
               flags = Intent.FLAG_GRANT_READ_URI_PERMISSION
           }

           //Asks the system to start another activity that can handle Intent
           startActivity(openPdfIntent)
       }

       //Gets a reference to the Button object
       val button = findViewById<Button>(R.id.button)

       //Binds button to start the file Picker
       button.setOnClickListener {
           //val input = emptyArray<String>() //this will match nothing.
           //val input = arrayOf("text/plain") //if you want to filter .txt files
           val input = arrayOf("application/pdf")
           openPdfLauncher.launch(input)
       }

   }

}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.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"
   tools:context=".MainActivity">

   <Button
       android:id="@+id/button"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/open_pdf"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

strings.xml

<resources>
   <string name="app_name">Daniweb Android Storage Access Framework</string>
   <string name="open_pdf">Open PDF</string>
</resources>

We have learned how to open a document using the Storage Access Framework. The full project code can be found at https://github.com/dmitrilc/DaniwebAndroidStorageAccessFramework

Pls let me know which tool or software to use to develop mobile app. I have 27 yes exp in vb6 and sql. Need to change to mobile app. Pls guide

I have updated my Android Studio to the Artic Fox Version. After that neither the projects with old Gradle versions running nor the new projects with latest Gradle versions running. Only the following errors appears: Could not install Gradle distribution from 'https: //services.gradle.org/distributions/gradle-7.0.2-bin.zip'

After this error I manually downloaded the Gradle 7.0.2, extracted it and Set it as Gradle path in Android Studio > File>Settings>Gradle and choose the option "Use Gradle from Specified Location". But all in vain. Only I can see the following message, when I try to Sync project with Gradle.

"The system cannot find the path specified." I have been searching this problem for two days on internet, but nothing worked out for me.

Current Path where I have downloaded and extracted the Gradle Distribution is follows F:/Android Gradle/gradle-7.0.2

What mistake I am making?

In Android development, the MediaStore API is a great API to use if you are building a music player. In this tutorial, we will learn how to query for audio files in the MediaStore database.

At the end of the tutorial, you would have learned:

1. How to query for Audio files from the MediaStore.

1. Android Studio. The version used in this tutorial is Arctic Fox 2020.3.1 Patch 4.

1. Intermediate Android
2. Android permissions.
3. ActivityResult API.
4. Basic SQL.

To follow along with the tutorial, perform the steps below:

1. Create a new Android project with the default Empty Activity.

2. Remove default Hello World! TextView.

3. Add a new Button under ConstraintLayout.

4. Constraint the Button to the center of the screen.

5. Extract the Button android:text value to strings.xml. Set the Resource Name to button_startQuery and Resource Value to Start Query.

6. Your activity_main.xml content should be similar to the code below.

    <?xml version="1.0" encoding="utf-8"?>
    <androidx.constraintlayout.widget.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"
       tools:context=".MainActivity">
   
       <Button
           android:id="@+id/button"
           android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@string/button_startQuery"
           app:layout_constraintBottom_toBottomOf="parent"
           app:layout_constraintEnd_toEndOf="parent"
           app:layout_constraintStart_toStartOf="parent"
           app:layout_constraintTop_toTopOf="parent" />
    </androidx.constraintlayout.widget.ConstraintLayout>

7. Download the .mp3 file called Unexpected Gifts of Spring by Alextree from the FreeMusicArchive. This song is licensed under CC BY 4.0.

The frontend of our project is quite simple. It only has a single button. When the project is completed, our App should be able to perform the workflow below:

1. User taps the Starts Query button.
2. If the App has not been granted the runtime(dangerous) permission of android.permission.READ_EXTERNAL_STORAGE, the App will request the user to grant this permission.
3. If the App has received the permission, it will then query the MediaStore database for entries matching the query parameters.
4. The App will log the query results via the debugging channel.

Because our App workflow requires the READ_EXTERNAL_STORAGE permission, so we will take care of that first. Based on the documentation, this permission is a runtime permission, so we must manually request it ourselves (API 23 or higher).

To add the permission request into our workflow, performs the steps below:

1. In AndroidManifest.xml, add the <uses-permission> element inside of <manifest>, but outside of <application>.

    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

2. Open up the file MainActivity.kt. Inside of onCreate(), add a reference to the Button object.

    val button = findViewById<Button>(R.id.button)

3. Below the button reference, add the code below to define an ActivityResultLauncher with an empty callback.

    val permissionResultLauncher = registerForActivityResult(RequestPermission()){ isGranted ->
   
    }

4. Add the code below to bind the Button onClickListener to the permissionResultLauncher#launch() action.

    button.setOnClickListener {
       permissionResultLauncher.launch(READ_EXTERNAL_STORAGE)
    }

5. You can run the app now if you wish just to see how the permission flow looks like. To clear the granted permission, either reinstall the app or use the adb revoke command below:

    adb shell pm revoke com.example.daniwebandroidqueryaudiomediastore android.permission.READ_EXTERNAL_STORAGE

The Android system has common public locations for Apps to store media files, such as Audio, Video, or Image. For this tutorial, we are only concerned about audio files; Android will automatically scan for audio files in the locations below.

• Alarms/
• Audiobooks/
• Music/
• Notifications/
• Podcasts/
• Ringtones/
• Recordings/

After scanning, it stores information about these files inside an internal database called MediaStore. To interact with this database, we can use the MediaStore API. When interacting with the MediaStore database, there are a couple of important things to keep in mind:

1. MediaStore only automatically refreshes its data at certain times, like a cold boot.
2. Apps can write entries to the MediaStore even if the actual files do not exist. A file can be deleted in a way that does not trigger MediaStore to update itself. Proper checking/error handling is recommended when attempting to play a media file.

Even though we are interacting with the MediaStore database via the MediaStore API, just like any SQL query, we will need to create our query. To do this, follow the steps below:

1. Inside the MainActivity class, create a new queryAudio() function.

    private fun queryAudio(){
    }

2. To send a SQL query to the MediaStore database, we would use the query() function from the ContentResolver object. We can retrieve the ContentResolver from the App Context. Add the code below into queryAudio().

    applicationContext.contentResolver.query(
       MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
       projection,
       selection,
       selectionArgs,
       sortOrder
    )

3. The query() function used here takes 5 arguments. Refer to the list below for a simplified explanation for them.
   a. uri: the location to query.
   b. projection: the columns that you want to be included.
   c. selection: this is where you put the SQL WHERE clause.
   d. selectionArgs: if you have any parameter used in the selection query (the previous function argument), you can provide values for them here.
   e. sortOrder: how you would like the result to be sorted.

4. Now let us define the arguments before the query() call.

    val projection = arrayOf(
       MediaStore.Audio.Media.TITLE,
       MediaStore.Audio.Media.ALBUM
    )
   
    val selection = null //not filtering out any row.
    val selectionArgs = null //this can be null because selection is also null
    val sortOrder = null //sorting order is not needed

The query() call returns a Cursor object, so we will need to use it to get the data.

1. Link the result of the query() call to a use clause (similar to Java try-with-resource) using the code below.

    applicationContext.contentResolver.query(
       MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
       projection,
       selection,
       selectionArgs,
       sortOrder
    )?.use { cursor ->
   
       val titleColIndex = cursor.getColumnIndex(MediaStore.Audio.Media.TITLE)
       val albumColIndex = cursor.getColumnIndex(MediaStore.Audio.Media.ALBUM)
   
       Log.d(TAG, "Query found ${cursor.count} rows")
   
       while (cursor.moveToNext()) {
           val title = cursor.getString(titleColIndex)
           val album = cursor.getString(albumColIndex)
   
           Log.d(TAG, "$title - $album")
       }
    }

2. The code snippet above will log the title and the album values to a logging channel.

3. Add the top-level TAG in MainActivity.kt.

    private const val TAG = "AUDIO_QUERY"

4. Call the query() function in your ActivityResultLauncher callback.

    val permissionResultLauncher = registerForActivityResult(RequestPermission()){ isGranted ->
       if (isGranted) queryAudio()
    }

Remember the audio file that we had to download earlier? You can find its metadata in the screenshot below. We expect that our App will output the correct value for Title and Album.

For MediaStore to generate an entry, we will upload the mp3 file directly to the file system and then reboot the device so MediaStore will refresh.

1. Boot your emulator now.
2. In Android Studio, open the Device File Explorer from View > Tool Windows > Device File Explorer.
3. Navigate to /storage/self/primary/Music.
4. Right-click on Music > Upload > select the mp3 file.

1. Cold reboot your emulator.

Now run the app while filtering Logcat for AUDIO_QUERY, and you will see that the App correctly logs the output.

2022-01-12 16:58:58.571 8415-8415/com.example.daniwebandroidqueryaudiomediastore D/AUDIO_QUERY: Query found 1 rows
2022-01-12 16:58:58.571 8415-8415/com.example.daniwebandroidqueryaudiomediastore D/AUDIO_QUERY: Unexpected Gifts of Spring - Glint EP

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.example.daniwebandroidqueryaudiomediastore">

   <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

   <application
       android:allowBackup="true"
       android:icon="@mipmap/ic_launcher"
       android:label="@string/app_name"
       android:roundIcon="@mipmap/ic_launcher_round"
       android:supportsRtl="true"
       android:theme="@style/Theme.DaniwebAndroidQueryAudioMediaStore">
       <activity
           android:name=".MainActivity"
           android:exported="true">
           <intent-filter>
               <action android:name="android.intent.action.MAIN" />

               <category android:name="android.intent.category.LAUNCHER" />
           </intent-filter>
       </activity>
   </application>

</manifest>

MainActivity.kt

package com.example.daniwebandroidqueryaudiomediastore

import android.Manifest.permission.READ_EXTERNAL_STORAGE
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.provider.MediaStore
import android.util.Log
import android.widget.Button
import androidx.activity.result.contract.ActivityResultContracts.RequestPermission

private const val TAG = "AUDIO_QUERY"

class MainActivity : AppCompatActivity() {

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)

       val button = findViewById<Button>(R.id.button)

       val permissionResultLauncher = registerForActivityResult(RequestPermission()){ isGranted ->
           if (isGranted) queryAudio()
       }

       button.setOnClickListener {
           permissionResultLauncher.launch(READ_EXTERNAL_STORAGE)
       }

   }

   private fun queryAudio(){
       val projection = arrayOf(
           MediaStore.Audio.Media.TITLE,
           MediaStore.Audio.Media.ALBUM
       )

       val selection = null //not filtering out any row.
       val selectionArgs = null //this can be null because selection is also null
       val sortOrder = null //sorting order is not needed

       applicationContext.contentResolver.query(
           MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
           projection,
           selection,
           selectionArgs,
           sortOrder
       )?.use { cursor ->

           val titleColIndex = cursor.getColumnIndex(MediaStore.Audio.Media.TITLE)
           val albumColIndex = cursor.getColumnIndex(MediaStore.Audio.Media.ALBUM)

           Log.d(TAG, "Query found ${cursor.count} rows")

           while (cursor.moveToNext()) {
               val title = cursor.getString(titleColIndex)
               val album = cursor.getString(albumColIndex)

               Log.d(TAG, "$title - $album")
           }
       }
   }

}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.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"
   tools:context=".MainActivity">

   <Button
       android:id="@+id/button"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/button_startQuery"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

strings.xml

<resources>
   <string name="app_name">Daniweb Android Query Audio MediaStore</string>
   <string name="button_startQuery">Start Query</string>
</resources>

We have learned how to use the MediaStore API to query the MediaStore database. The full project code can be found at https://github.com/dmitrilc/DaniwebAndroidQueryAudioMediaStore

Hello i have an Angular 12 project and i want to retrieve all results in artisticBehaviour (except those who are NULL or same e.g. Actor, Actor) column in Users table.

ts function that i call all users from Users table.

allArtistsSet() {
    this.userData.allArtists(this.offset).pipe(
      map((data: any) => {
        if (data.success) {
            this.allArtists = data.artistsFeed;
 this.creativenessArtists = this.allArtists.filter((data) => data.artisticBehaviour != null);
        }
      })
    ).subscribe()
  }

html

<select style="background-color: #333;color: whitesmoke;padding: 5px;font-size: small; border-radius: 5px;width: 110px;">
                <option disabled>Creative Behaviour</option>
                <option>Creativeness</option>
                <option *ngFor="let creative of creativenessArtists" value="{{creative}}">{{creative}}</option>
                </select>

WorkManager is the preferred method of managing background tasks on Android. It also includes convenient extensions for RxJava3 and Kotlin Coroutines.

In this tutorial, we will learn how to use WorkManager as well as how to observe the background task with the debugging tool Background Task Inspector.

At the end of the tutorial, you would have learned:

1. How to use WorkManager.
2. How to use the Background Task Inspector.

1. Android Studio. The version used in this tutorial is Arctic Fox 2020.3.1 Patch 4.

1. Basic Android.

To follow along with the tutorial, perform the steps below:

1. Create a new Android project with the default Empty Activity.

2. Add the WorkManger dependency to your module build.gradle file.

    def work_version = "2.7.1"
   
    implementation "androidx.work:work-runtime-ktx:$work_version"

3. Remove the default Hello World! TextView.

4. Add a new Button inside ConstraintLayout.

5. Constrain the Button to the center of ConstraintLayout.

6. Extract the Button android:text value to strings.xml, using download_button as the resource name and Download File as the Resource value.

Your activity_main.xml should look similar to the code below.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.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"
   tools:context=".MainActivity">

   <Button
       android:id="@+id/button"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/button_download"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

Before writing any code, we will first need to know about the primary classes of WorkManager. Most of the classes related to WorkManager can be found in the androidx.work package. The most basic classes are Worker, WorkRequest, and WorkManager.

1. WorkManager: This class is responsible for submitting WorkRequest objects to the system. It can also cancel and read Workers. By default, the WorkManager starts itself when your App is started, so in most cases, you do not have to initialize WorkManager yourself.
2. WorkRequest: Represents a work request, which WorkManager submits to the system. You can build custom WorkRequest objects with WorkRequest.Builder or use the two existing concrete implementations OneTimeWorkRequest or PeriodicWorkRequest. You can create OneTimeWorkRequest objects by wrapping Worker objects.
3. Worker: This class contains code to perform the actual work for your App. Worker is abstract, so you will need to override it and implement the doWork() function.
4. ListenableWorker.Result: The object that you must return from Work#doWork(). You can create Result objects by calling Results static functions failure(), retry(), and success().
5. WorkInfo.State: Your work moves through different stages in the system. There are six different stages for your work: BLOCKED, CANCELLED, ENQUEUED, FAILED, RUNNING, SUCCEEDED.

For this tutorial, we will have our app start a fake download WorkRequest. When the user taps Download File, the background thread that executes the work request will wait for 1 second before reporting back the ListenableWorker.Result status.

We will also use the Background Task Inspector debugging facility to observe our work progress.

It is finally time to write some code. Our first task is to create a concrete implementation of Worker.

1. In the same package as the MainActivity class, create a new Kotlin class called DownloadWorker.kt.

    class DownloadWorker {
   
    }

2. Add Worker as the parent.

    class DownloadWorker(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {
   
    }

3. Implement the doWork() function. This implementation will wait for 1 second and return a SUCCESS status.

    override fun doWork(): Result {
        Thread.sleep(1_000L)
   
        return Result.success()
    }

As stated previously, a default WorkManager is automatically initialized by our App on startup. Because our use case is quite simple and does not require a custom WorkManager, we can just use the default WorkManager instance using the convenient static function WorkManger#getInstance().

1. Inside MainActivity.kt#onCreate(), append the line of code below.

    val workManager = WorkManager.getInstance(applicationContext)

2. Create the a OneTimeWorkRequest object by appending the line of code below to onCreate(). You must pass in the Java class object to the from() function.

    val oneTimeDownloadWorkRequest = OneTimeWorkRequest.from(DownloadWorker::class.java)

3. Append the line of code below to onCreate() retrieve the Button object.

    val button = findViewById<Button>(R.id.button)

4. Bind the Button click to the work request in onCreate().

    button.setOnClickListener {
       workManager.enqueue(oneTimeDownloadWorkRequest)
    }

The Background Task Inspector is a special debugging facility available when your WorkManager runs at Android API level 26 or above. To see how it works, follow the steps below:

1. In Android Studio, go to View > Tool Windows > App Inspection.
2. This tool also contains the Database Inspector, so ignore that tab for now. When your App is started, switch to the Background Task Inspector.
   
3. Run the App.
4. Taps Download File button in your App and observe the background job being executed.

DownloadWorker.kt

package com.example.daniwebandroidworkmanager

import android.content.Context
import androidx.work.Worker
import androidx.work.WorkerParameters

class DownloadWorker(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {

   override fun doWork(): Result {
       Thread.sleep(1_000L)

       return Result.success()
   }

}

MainActivity.kt

package com.example.daniwebandroidworkmanager

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import androidx.work.OneTimeWorkRequest
import androidx.work.WorkManager

class MainActivity : AppCompatActivity() {
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)

       val workManager = WorkManager.getInstance(applicationContext)
       val oneTimeDownloadWorkRequest = OneTimeWorkRequest.from(DownloadWorker::class.java)

       val button = findViewById<Button>(R.id.button)

       button.setOnClickListener {
           val operation = workManager.enqueue(oneTimeDownloadWorkRequest)
       }
   }
}

strings.xml

<resources>
   <string name="app_name">Daniweb Android WorkManager</string>
   <string name="button_download">Download File</string>
</resources>

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.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"
   tools:context=".MainActivity">

   <Button
       android:id="@+id/button"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/button_download"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

We have learned how to use WorkManager and the Background Task Inspector. The full project code can be found at https://github.com/dmitrilc/DaniwebAndroidWorkManager

I've been code for android/ios using flutter more than a year. Now I would like to learn new things by using software to create image instead of just getting icons from google material design (just like image below).

Any recommended ? Thanks.

Regardless of whether you like notches on your devices or not, they exist, so as developers, we will have to adapt our Apps to work with them. In this tutorial, we will learn how to adapt our code to work with notches.

The device used in this example is the Pixel 3 XL because Android Studio already provides an AVD skin for this device.

At the end of the tutorial, you would have learned:

1. How to adapt your App to work with display cutouts.

1. Android Studio. The version used in this tutorial is Arctic Fox 2020.3.1 Patch 4.

1. Basic Android.

To follow along with the tutorial, perform the steps below:

1. Create a new Android project with the default Empty Activity.

2. In Android Studio, open the AVD Manager by going to Tools > AVD Manager.

3. Select Create Virtual Device from the bottom left.
   

4. In the Phone Category, select the Pixel 3 XL, then hit Next.
   

5. Select the Android S Image with API Level 32 (x86 or ARM depends on your PC), and hit Next.
   

6. On the last screen, verify that Enable Device Frame is checked, and then hit Finish.
   

7. Create another AVD with the exact same configuration, but without the Device Frame.

8. I was unable to find any documentation about whether the emulator is aware of the display cutout, but based on testing, the emulator is, in fact, aware of cutout areas from emulator skins, without requiring the developer to turn on Display cutout emulation in Developer settings. In the picture below, you can clearly see how the notification bar renders its content in a way that does not obstruct the emulator skin.
   

9. In themes.xml, replace the current theme of

    parent="Theme.MaterialComponents.DayNight.DarkActionBar"

   with

    parent="Theme.MaterialComponents.DayNight.NoActionBar"

10. In strings.xml, add the text element below. The string is A-z to make it easy to check the overlay behavior later.

     <string name="super_long_text">AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz</string>

11. Replace your activity_main.xml with the xml content below. The modified layout removes the bottom constraint of the TextView as well as setting its text value to the string resource declared in the previous step.

     <?xml version="1.0" encoding="utf-8"?>
     <androidx.constraintlayout.widget.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"
        tools:context=".MainActivity">
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/super_long_text"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
    
     </androidx.constraintlayout.widget.ConstraintLayout>

12. Add the below style element into your main themes.xml file (outside of the current <style>, but still inside <resources> pairs). Make sure to modify the parent attribute because your base theme will have a different name compared to mine.

     <style name="AppTheme" parent="Theme.DaniwebCutoutArea" />

13. Create a new resource file for Android API 27 (I will explain why later). Right-click on themes > New > Values Resource File. Add the qualifier and name the file themes.
    

14. Paste the content below into the new resource file (themes.xml (v27)) to override your base theme. Modify the parent attribute if necessary.

     <resources xmlns:tools="http://schemas.android.com/tools">
        <!-- Base application theme. -->
        <style name="AppTheme" parent="Theme.DaniwebCutoutArea">
            <!-- Customize your theme here. -->
        </style>
     </resources>

15. In AndroidManifest.xml, replace the current android:theme attribute with the attribute below.

     android:theme="@style/AppTheme"

16. Launch the app on both devices simultaneously by going to Run > Select Device >Select Multiple Devices > Check your two devices > OK > click the Play button to run the app on both AVDs.
    

You should now see something similar to the screenshot with the app running on both AVDs side-by-side.

Display cutouts tend to present more problems to fullscreen Apps than non-fullscreen Apps. When your app needs to utilize the entire screen, by default, devices with a notch will refuse to allow your App to render inside the cutout area.

To understand this, first, let us attempt to make our App display in full screen. At the minimum, on Systems without a notch, you must do at least one thing for your app to display in fullscreen:

1. Hide the System bars.

To do this, add the lines of code below into the onCreate() callback in MainActivity.kt, after the setContentView() call.

//Hide the system bars
val windowInsetsController: WindowInsetsControllerCompat? = ViewCompat.getWindowInsetsController(window.decorView) //gets WindowInsetsController
windowInsetsController?.hide(WindowInsetsCompat.Type.systemBars()) //Hides system bars (notification bar + navigation bar)

Now lets run our app on both emulators. When we put them side by side, the device with the notch would not completely go fullscreen, while the device without the notch displays in full screen perfectly.

For systems with a notch, there are two more things that we must do to display our App in full screen.

1. Set the top-level Window object to display behind the System bars (notification and navigation bars). At the end of the onCreate() callback, add the code below.

    //Enables Edge 2 Edge, allowing the app window to extend behind the system bars
    WindowCompat.setDecorFitsSystemWindows(window, false)

2. Add an <item> with the name android:windowLayoutInDisplayCutoutMode to the extended App Theme (themes.xml (v27)). This property was introduced on Android 8.1 to support display cutout in XML. Add the <item> below inside <style> in the themes.xml (v27) file to set the mode to shortEdges.

           <item name="android:windowLayoutInDisplayCutoutMode">
    <!--            default-->
               shortEdges
    <!--            never-->
    <!--            always-->
           </item>

Optionally, you can also modify layoutInDisplayCutoutMode programmatically by setting a new value to window.attributes.layoutInDisplayCutoutMode.

If we run the App now, we can see that the text now takes advantage of the entire screen space.

We also know that the text displays behind the notch by looking at the cutoff character h and the resuming character S. The characters behind the notch are IiJjKkLlMmNnOoPpQqRr. This is similar to the Youtube app (need to emulate pinch-to-zoom gesture first).

MainActivity.kt

package com.example.daniwebcutoutarea

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.core.view.ViewCompat
import androidx.core.view.WindowCompat
import androidx.core.view.WindowInsetsCompat
import androidx.core.view.WindowInsetsControllerCompat

class MainActivity : AppCompatActivity() {
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)

       //Hide the system bars
       val windowInsetsController: WindowInsetsControllerCompat? = ViewCompat.getWindowInsetsController(window.decorView) //gets WindowInsetsController
       windowInsetsController?.hide(WindowInsetsCompat.Type.systemBars()) //Hides system bars (notification bar + navigation bar)

       //Enables Edge 2 Edge, allowing the app window to extend behind the system bars
       WindowCompat.setDecorFitsSystemWindows(window, false)
   }

}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.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"
   tools:context=".MainActivity">

   <TextView
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/super_long_text"
       app:layout_constraintLeft_toLeftOf="parent"
       app:layout_constraintRight_toRightOf="parent"
       app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

strings.xml

<resources>
   <string name="app_name">Daniweb Cutout Area</string>
   <string name="super_long_text">AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz</string>
</resources>

themes.xml

<resources xmlns:tools="http://schemas.android.com/tools">
   <!-- Base application theme. -->
   <style name="Theme.DaniwebCutoutArea" parent="Theme.MaterialComponents.DayNight.NoActionBar">
       <!-- Primary brand color. -->
       <item name="colorPrimary">@color/purple_500</item>
       <item name="colorPrimaryVariant">@color/purple_700</item>
       <item name="colorOnPrimary">@color/white</item>
       <!-- Secondary brand color. -->
       <item name="colorSecondary">@color/teal_200</item>
       <item name="colorSecondaryVariant">@color/teal_700</item>
       <item name="colorOnSecondary">@color/black</item>
       <!-- Status bar color. -->
       <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
       <!-- Customize your theme here. -->
   </style>
   <style name="AppTheme" parent="Theme.DaniwebCutoutArea"/>
</resources>

themes.xml (v27)

<resources xmlns:tools="http://schemas.android.com/tools">
   <!-- Base application theme. -->
   <style name="AppTheme" parent="Theme.DaniwebCutoutArea">
<!--         Customize your theme here.-->
       <item name="android:windowLayoutInDisplayCutoutMode">
<!--            default-->
           shortEdges
<!--            never-->
<!--            always-->
       </item>
   </style>
</resources>

We have learned how to implement support for devices with display cutouts. Even though we only covers the short edge mode in this tutorial, the concept applies similarly to other display modes.

1. Default: Only renders into the cutout area in landscape mode.
2. Always: Always extend into the cutout area on both short and long edges. I have not seen any device with a camera cutout on the long edge. The only examples that I can think of are those curved Galaxy Edge devices.
3. Never: Never extend into the cutout area.
4. Short edge: Always extend into the cutout area on short edges only.

The full project code can be found here.

In Android development, Espresso can be combined with Junit to create powerful UI automation tests. In this tutorial, we will learn how to create Espresso tests.

At the end of the tutorial, you would have learned:

1. How to create Espresso tests.

1. Android Studio. The version used in this tutorial is Arctic Fox 2020.3.1 Patch 4.

1. Basic Android.

To follow along with the tutorial, perform the steps below:

1. Create a new Android project with the default Empty Activity.

2. Replace the content of activity_main.xml with the layout XML below.

    <?xml version="1.0" encoding="utf-8"?>
    <androidx.constraintlayout.widget.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"
       tools:context=".MainActivity">
   
       <EditText
           android:id="@+id/editText_plaintTextInput"
           android:layout_width="match_parent"
           android:layout_height="wrap_content"
           android:layout_marginStart="16dp"
           android:layout_marginEnd="16dp"
           android:hint="@string/input_text_here"
           android:inputType="text"
           app:layout_constraintBottom_toTopOf="@id/button_submit"
           app:layout_constraintEnd_toEndOf="parent"
           app:layout_constraintStart_toStartOf="parent"
           app:layout_constraintTop_toTopOf="parent" />
   
       <Button
           android:id="@+id/button_submit"
           android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:text="@string/button"
           app:layout_constraintBottom_toTopOf="@id/textView_finalText"
           app:layout_constraintEnd_toEndOf="parent"
           app:layout_constraintHorizontal_bias="0.5"
           app:layout_constraintStart_toStartOf="parent"
           app:layout_constraintTop_toBottomOf="@id/editText_plaintTextInput" />
   
       <TextView
           android:id="@+id/textView_finalText"
           android:layout_width="wrap_content"
           android:layout_height="wrap_content"
           android:hint="@string/no_value"
           app:layout_constraintBottom_toBottomOf="parent"
           app:layout_constraintEnd_toEndOf="parent"
           app:layout_constraintHorizontal_bias="0.5"
           app:layout_constraintStart_toStartOf="parent"
           app:layout_constraintTop_toBottomOf="@id/button_submit" />
   
    </androidx.constraintlayout.widget.ConstraintLayout>

3. Replace strings.xml with the xml below.

    <resources>
       <string name="app_name">Daniweb Espresso Test</string>
       <string name="button">SUBMIT</string>
       <string name="no_value">No Value</string>
       <string name="input_text_here">Input text here</string>
    </resources>

Even though all of the boilerplate code has been provided for this tutorial, let us quickly go over the state of the demo app right now.

First, launch the app, and we can see that there are three elements in our application:

1. An EditText element for users to input plain text. It provides a hint of Input text here to let the user know that they should provide some text value here.
2. A Button element for submitting the text. The actual button action is not yet implemented. Once implemented, we would want the text value(android:text) of EditText to be set as the TextView text value as well.
3. A TextView element for displaying the text value submitted from the EditText element. If the TextView android:text value is empty, it will display No Value.

When Espresso is mentioned together with modern Android development, it can mean two things:

1. The androidx.test.espresso package. This package includes the core classes of the library. Other subpackages of Espresso can be used if you need support for more complicated workflows. For example, if you need to test WebView, you would need the androidx.test.espresso.web.* packages.
2. The androidx.test.espresso.Espresso class. This class is the main entry point for Espresso tests.

The flow of an Espresso test is quite simple. They are:

1. Start the test by using one of the static methods from the Espresso class. For this tutorial, we will use the Espresso.onView() method.
2. Providing a Hamcrest matcher object to onView() (or other entry points such as onData()). You can obtain pre-made Matcher objects from the ViewMatchers class( androidx.test.espresso.matcher.ViewMatchers).
3. onView() will return a ViewInteraction object. Via this ViewInteraction object, we can call the method perform() to perform actions on the underlying View. The method perform() takes a varargs of ViewAction objects. Each ViewAction object represents an action to perform. You can obtain pre-implemented ViewAction objects from the ViewActions class(androidx.test.espresso.action.ViewActions).
4. The call to perform() will return the same ViewInteraction object, which we can then call its instance method check() to provide assertions to verify whether the test has passed. Each assertion is encapsulated in a ViewAssertion object. One convenient way to obtain ViewAssertion objects is to use static methods of the ViewAssertions class(androidx.test.espresso.assertion.ViewAssertions).

For this tutorial, we will attempt to use Espresso in an instrumentation test. There should already be a test class under androidTest, so we can just re-use that file for simplicity. The class name in my project is ExampleInstrumentedTest. To create our own Espresso test, perform the steps below:

1. Copy and paste this JUnit rule inside the ExampleInstrumentedTest class. This is a special rule used with AndroidJunitRunner that starts the Activity (MainActivity in our case) before each test and stops the Activity at the end of each test. Check the code comment if you want to read more about this Rule, but discussing this Rule is out of scope for this tutorial.

    /**
    * Check https://developer.android.com/training/testing/junit-rules#activity-test-rule
    */
    @get:Rule
    val activityScenarioRule = ActivityScenarioRule(MainActivity::class.java)

2. Remove the default useAppContext() test from the class because we do not need it.

3. Paste the code below into the test class.

    @Test
    fun testFinalTextView() {
       val testString = "Daniweb Espresso Test"
   
       onView(withId(R.id.editText_plaintTextInput)) //Obtains the TextEdit element
           .perform(typeText(testString)) //Add text to the TextEdit field
   
       onView(withId(R.id.button_submit)) //Obtains the Button element
           .perform(click()) //Click on the Submit button
   
       onView(withId(R.id.textView_finalText)) //Obtains the TextView element
           .check(matches(withText(testString))) //Checks if its value matches the submitted value
    }

The method testFinalTextView() attempts to replicate the expected flow. The code comments above explains what the code does on each line.

We are ready to run the test.

1. Right-click on the Test class, in the Project view.
2. RunExampleInstrumentedTest.

Then you can see that the test will fail with the error:

Expected: an instance of android.widget.TextView and view.getText() with or without transformation to match: is "Daniweb Espresso Test"
     Got: view.getText() was "" transformed text was ""

This behavior is expected because we have not implemented any logic for the Submit button yet. To quickly implement the logic, replace the current onCreate() function in MainActivity.kt with the new version below.

override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   setContentView(R.layout.activity_main)

   val editText = findViewById<EditText>(R.id.editText_plaintTextInput)
   val button = findViewById<Button>(R.id.button_submit)
   val finalText = findViewById<TextView>(R.id.textView_finalText)

   button.setOnClickListener {
       finalText.text = editText.text
   }
}

With the logic implemented, we can run the test again and see it passing.

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.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"
   tools:context=".MainActivity">

   <EditText
       android:id="@+id/editText_plaintTextInput"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:layout_marginStart="16dp"
       android:layout_marginEnd="16dp"
       android:hint="@string/input_text_here"
       android:inputType="text"
       app:layout_constraintBottom_toTopOf="@id/button_submit"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent" />

   <Button
       android:id="@+id/button_submit"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/button"
       app:layout_constraintBottom_toTopOf="@id/textView_finalText"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintHorizontal_bias="0.5"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toBottomOf="@id/editText_plaintTextInput" />

   <TextView
       android:id="@+id/textView_finalText"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:hint="@string/no_value"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintHorizontal_bias="0.5"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toBottomOf="@id/button_submit" />

</androidx.constraintlayout.widget.ConstraintLayout>

strings.xml

<resources>
   <string name="app_name">Daniweb Espresso Test</string>
   <string name="button">SUBMIT</string>
   <string name="no_value">No Value</string>
   <string name="input_text_here">Input text here</string>
</resources>

MainActivity.kt

package com.example.daniwebespressotest

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.TextView

class MainActivity : AppCompatActivity() {
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)

       val editText = findViewById<EditText>(R.id.editText_plaintTextInput)
       val button = findViewById<Button>(R.id.button_submit)
       val finalText = findViewById<TextView>(R.id.textView_finalText)

       button.setOnClickListener {
           finalText.text = editText.text
       }
   }
}

ExampleInstrumentedTest.kt

package com.example.daniwebespressotest

import androidx.test.espresso.Espresso.onView
import androidx.test.espresso.action.ViewActions.click
import androidx.test.espresso.action.ViewActions.typeText
import androidx.test.espresso.assertion.ViewAssertions.matches
import androidx.test.espresso.matcher.ViewMatchers.withId
import androidx.test.espresso.matcher.ViewMatchers.withText
import androidx.test.ext.junit.rules.ActivityScenarioRule
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4

import org.junit.Test
import org.junit.runner.RunWith

import org.junit.Assert.*
import org.junit.Rule

/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {

   /**
    * Check https://developer.android.com/training/testing/junit-rules#activity-test-rule
    */
   @get:Rule
   val activityScenarioRule = ActivityScenarioRule(MainActivity::class.java)

   @Test
   fun testFinalTextView() {
       val testString = "Daniweb Espresso Test"

       onView(withId(R.id.editText_plaintTextInput)) //Obtains the TextEdit element
           .perform(typeText(testString)) //Add text to the TextEdit field

       onView(withId(R.id.button_submit)) //Obtains the Button element
           .perform(click()) //Click on the Submit button

       onView(withId(R.id.textView_finalText)) //Obtains the TextView element
           .check(matches(withText(testString))) //Checks if its value matches the submitted value
   }
}

Congratulations, we have learned how to create UI Automation tests with Espresso. The full project code can be found here https://github.com/dmitrilc/DaniwebEspressoTest.

UI Automator is a library that allows you to create tests that can interact with other components besides your App, such as Settings or other Android components. In this tutorial, we will learn how to incorporate UI Automator into our tests.

At the end of the tutorial, you would have learned:

1. How to use UI Automator to create tests.

1. Android Studio. The version used in this tutorial is Arctic Fox 2020.3.1 Patch 4.

1. Basic Android.

To follow along with the tutorial, perform the steps below:

1. Create a new Android project with the default Empty Activity.

2. Give the default TextView the android:id of textView_helloWorld

3. Add the dependency for Ui Automator to your module gradle file.

    androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.2.0'

UI Automator simply refers to a group of classes belonging to the androidx.test.uiautomator package. The primary classes that you need to know in this package are:

1. UiDevice: allows you to access device state and simulate user actions. to simulate user actions, you can use methods such as click(), drag(), pressX(), etc.
2. UiObject: represents a view. You can obtain UiObject instances via findObject() methods from the UiDevice class. UiObjects public constructors are deprecated. You can also reuse this object for different views matching the same UiSelector.
3. UiSelector: a filter object used to create a UiObject. If you are familiar with Hamcrest Matchers, then this is somewhat similar to the ViewMatchers class (androidx.test.espresso.matcher.ViewMatchers).

We are only using the default Empty Activity project to simplify the tutorial. For this UI Automator test, we will attempt to switch the App to the Dark theme using the system-wide Display setting on Android. The launcher used in the test is the default Android 12 launcher on a Pixel emulator (Pixel 4 XL API 31).

Our test includes 10 steps, when not including the Activity launcher step.

1. When the demo App is the foreground App, press the Home button.
2. Swipe up from anywhere on the home screen to open the launcher.
3. Open the Settings app.
4. After the Settings app is opened, swipe up a little to scroll down on the list.
5. Open the Display setting.
6. Switch on Dark theme.
7. Open the Recents button.
8. Swipe right to put our app into focus.
9. Resume our App.
10. Verify that our App is in Dark mode.

Refer to the picture below for a preview of the desired flow of the test.

Before we are able to write any code, we must use the UI Automator Viewer (uiautomatorviewer) tool to inspect the UI elements that we want to test. As of this writing, this tool can only be launched from the CLI.

uiautomatorviewer is part of the Android SDK and not part of IntelliJ, so you can find it where the SDK is installed. On a Windows machine, for my Android Studio build, the default location is at:

C:\Users\%USERNAME%\AppData\Local\Android\Sdk\tools\bin\uiautomatorviewer.bat

If you are not using Windows, you can find the location of the Android SDK in IntelliJ by doing:

1. File > Settings > Appearance & Behavior > System Settings > Android SDK
2. Find the Android SDK Location property.

You can also just search for Android SDK Location using IntelliJs Search Everywhere functionality (press double Shift).

From the builtin IntelliJ terminal, navigate to the UI Automator Viewer directory with the command below.

cd C:\Users\%USERNAME%\AppData\Local\Android\Sdk\tools\bin\

Launch the uiautomatorviewer by calling uiautomatorviewer.bat.

tools\bin\uiautomatorviewer.bat

As of this writing, uiautomatorviewer only works if your JAVA_HOME is set to Java 8. You can also just create a wrapper around the uiautomator.bat file to modify JAVA_HOME just for the terminal session if you do not want to change your system-wide JAVA_HOME. The same workaround also applies to Linux/MacOS when JAVA_HOME is not set to Java 8.

After launching the uiautomatorviewer, make sure that your Emulator is running. Press the Device Screenshot button at the left corner of the uiautomatorviewer tool.

It will generate a static XML tree of UI elements that is currently on the screen.

Using this tool, you can extract details about an element and use them to write your test code. Some useful node attributes are text, resource-id, class, package, content-desc. In the next section, we will see what a complete UI Automator test looks like.

We are now ready to write our test.

1. In the ExampleInstrumentedTest file, remove the useAppContext() test method.

2. Set the ActivityScenarioRule in the class to launch our MainActivity when the test starts.

    /**
    * Check https://developer.android.com/training/testing/junit-rules#activity-test-rule
    */
    @get:Rule
    val activityScenarioRule = ActivityScenarioRule(MainActivity::class.java)

3. Copy and paste the test function below into your test class.

    @Test
    fun testDarkModeSwitch(){
       //Obtains the instrumented device
       val device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
   
       device.pressHome() //Press the Home button
   
       val homeScreen = device.findObject(UiSelector() //Starts the findObject query
           .resourceId("android:id/content") //Tries to match the element resource id
           .className(FrameLayout::class.java) //Tries to match the element class name
           .packageName("com.google.android.apps.nexuslauncher")) //Tries to match the package name. UiDevice.getPackageName might be cleaner
   
       homeScreen.waitForExists(1_000) //this is one option to wait for the View to load
   
       homeScreen.swipeUp(10) //Swipes up to open the Launcher
   
       val settingsIcon = device.findObject(UiSelector()
           .resourceId("com.google.android.apps.nexuslauncher:id/icon")
           .className(TextView::class.java)
           .packageName("com.google.android.apps.nexuslauncher")
           .descriptionContains("Settings")
       )
   
       settingsIcon.waitForExists(1_000)
   
       settingsIcon.click()
   
       //UiScrollable provides better API to interact with the Settings RecyclerView
       val settingsView = UiScrollable(UiSelector()
           .resourceId("com.android.settings:id/main_content_scrollable_container")
           .className(ScrollView::class.java)
           .packageName("com.android.settings")
       )
   
       settingsView.waitForExists(1_000)
   
       val displayOption = device.findObject(UiSelector()
           .text("Display")
           .resourceId("android:id/title")
           .className(TextView::class.java)
           .packageName("com.android.settings")
       )
   
       settingsView.scrollIntoView(displayOption)
   
       displayOption.waitForExists(1_000)
   
       displayOption.click()
   
       val darkThemeSwitch = device.findObject(UiSelector()
           .resourceId("com.android.settings:id/switchWidget")
           .className(Switch::class.java)
           .packageName("com.android.settings")
           .descriptionContains("Dark theme")
       )
   
       darkThemeSwitch.waitForExists(1_000)
   
       darkThemeSwitch.click()
   
       device.pressRecentApps() //Recents is black box because uiautomatorviewer is unable to spy the Recents View
   
       device.pressKeyCode(KeyEvent.KEYCODE_APP_SWITCH)
   
       val app = device.findObject(UiSelector()
           .packageName("com.example.daniwebuiautomatortest")
       )
   
       app.waitForExists(1_000)
   
       val context = InstrumentationRegistry.getInstrumentation().targetContext
   
       val isDark = context
           .resources
           .configuration.
           isNightModeActive
   
       assert(isDark)
    }

A few notes about the code snippet above.

1. It is quite long and the comments are too verbose, so it can be hard to read in real life, but I find it easier to read in a blog post because the method names are mostly self-explanatory. In real code, you should perform some refactoring to improve readability.
2. The UI Automator Viewer is unable to spy the Navigation Buttons and the Recents screen, so pressKeyCode() was used as a workaround.
3. My UiSelector queries were way overkill, but I mainly wanted to introduce the API.

We are now ready to run the test. Right-click on ExampleInstrumentedTest in the Project view and select Run ExampleInstrumentedTest.

And we can see that the test has passed. The animation above was compressed to save bandwidth; the actual test takes about 7-12 seconds on my computer.

ExampleInstrumentedTest.kt

package com.example.daniwebuiautomatortest

import android.view.KeyEvent
import android.widget.FrameLayout
import android.widget.ScrollView
import android.widget.Switch
import android.widget.TextView
import androidx.test.ext.junit.rules.ActivityScenarioRule
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.uiautomator.*

import org.junit.Test
import org.junit.runner.RunWith

import org.junit.Rule

/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {

   /**
    * Check https://developer.android.com/training/testing/junit-rules#activity-test-rule
    */
   @get:Rule
   val activityScenarioRule = ActivityScenarioRule(MainActivity::class.java)

   @Test
   fun testDarkModeSwitch(){
       //Obtains the instrumented device
       val device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())

       device.pressHome() //Press the Home button

       val homeScreen = device.findObject(UiSelector() //Starts the findObject query
           .resourceId("android:id/content") //Tries to match the element resource id
           .className(FrameLayout::class.java) //Tries to match the element class name
           .packageName("com.google.android.apps.nexuslauncher")) //Tries to match the package name. UiDevice.getPackageName might be cleaner

       homeScreen.waitForExists(1_000) //this is one option to wait for the View to load

       homeScreen.swipeUp(10) //Swipes up to open the Launcher

       val settingsIcon = device.findObject(UiSelector()
           .resourceId("com.google.android.apps.nexuslauncher:id/icon")
           .className(TextView::class.java)
           .packageName("com.google.android.apps.nexuslauncher")
           .descriptionContains("Settings")
       )

       settingsIcon.waitForExists(1_000)

       settingsIcon.click()

       //UiScrollable provides better API to interact with the Settings RecyclerView
       val settingsView = UiScrollable(UiSelector()
           .resourceId("com.android.settings:id/main_content_scrollable_container")
           .className(ScrollView::class.java)
           .packageName("com.android.settings")
       )

       settingsView.waitForExists(1_000)

       val displayOption = device.findObject(UiSelector()
           .text("Display")
           .resourceId("android:id/title")
           .className(TextView::class.java)
           .packageName("com.android.settings")
       )

       settingsView.scrollIntoView(displayOption)

       displayOption.waitForExists(1_000)

       displayOption.click()

       val darkThemeSwitch = device.findObject(UiSelector()
           .resourceId("com.android.settings:id/switchWidget")
           .className(Switch::class.java)
           .packageName("com.android.settings")
           .descriptionContains("Dark theme")
       )

       darkThemeSwitch.waitForExists(1_000)

       darkThemeSwitch.click()

       device.pressRecentApps() //Recents is black box because uiautomatorviewer is unable to spy the Recents View

       device.pressKeyCode(KeyEvent.KEYCODE_APP_SWITCH)

       val app = device.findObject(UiSelector()
           .packageName("com.example.daniwebuiautomatortest")
       )

       app.waitForExists(1_000)

       val context = InstrumentationRegistry.getInstrumentation().targetContext

       val isDark = context
           .resources
           .configuration.
           isNightModeActive

       assert(isDark)
   }

}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.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"
   tools:context=".MainActivity">

   <TextView
       android:id="@+id/textView_helloWorld"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Hello World!"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintLeft_toLeftOf="parent"
       app:layout_constraintRight_toRightOf="parent"
       app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

build.gradle

plugins {
   id 'com.android.application'
   id 'kotlin-android'
}

android {
   compileSdk 31

   defaultConfig {
       applicationId "com.example.daniwebuiautomatortest"
       minSdk 21
       targetSdk 31
       versionCode 1
       versionName "1.0"

       testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
   }

   buildTypes {
       release {
           minifyEnabled false
           proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
       }
   }
   compileOptions {
       sourceCompatibility JavaVersion.VERSION_1_8
       targetCompatibility JavaVersion.VERSION_1_8
   }
   kotlinOptions {
       jvmTarget = '1.8'
   }
}

dependencies {

   implementation 'androidx.core:core-ktx:1.7.0'
   implementation 'androidx.appcompat:appcompat:1.4.0'
   implementation 'com.google.android.material:material:1.4.0'
   implementation 'androidx.constraintlayout:constraintlayout:2.1.2'
   testImplementation 'junit:junit:4.+'
   androidTestImplementation 'androidx.test.ext:junit:1.1.3'
   androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
   androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.2.0'
}

We have learned how to use UI Automator library to create tests as well as how to use the uiautomatorviewer tool to design tests. The full project code can be found here https://github.com/dmitrilc/DaniwebUiAutomatorTest