DEV Community: Nwokocha wisdom maduabuchi

# How to Deploy a Word Counter Application to AWS S3 Bucket

Nwokocha wisdom maduabuchi — Wed, 06 Mar 2024 11:32:36 +0000

AWS S3 is a cloud storage service provided by Amazon Web Services. It is a simple storage service that offers scalability, security, and performance for storing and retrieving data.

S3 allows developers to host static websites, store and retrieve data anytime, and manage data using a web interface.

You’ll deploy a word counter application using an AWS S3 bucket. You can access this application in a web browser at the end of this article.

What is an S3 Bucket?

Amazon Simple Storage Service S3 is a scalable object storage service offered by AWS. It allows you to store and retrieve data from anywhere on the web.

An S3 bucket is essentially a container for objects stored in S3. It serves as the top-level folder in which you store your files.

S3 is an object storage service that stores data as objects in containers called buckets. An object can be any kind of file: a text file, an image, a video, etc.

Project Overview

This project will use the AWS console to create an S3 bucket and deploy a word counter application to the bucket.

The word counter application contains HTML, CSS, and JavaScript files. The application will count the number of words in a given text.

Once the bucket is created, you'll upload the Word Counter application files to it and make it public to access it using a web browser.

Prerequisites

This tutorial assumes that you have an AWS account and are familiar with the AWS Management Console. Every other step will be explained in detail.

Application setup

This word counter app can be found on GitHub. Clone the repository to your local machine using the following command:

git clone https://github.com/Aahil13/Word-counter.git

The word counter application contains the following files:

index.html: The main HTML file that contains the structure of the application.
style.css: The CSS file that contains the styles for the application.
index.js: The JavaScript file that contains the logic for the word counter application.
README.md: The README file that contains the instructions for running the application.
Dockerfile: The Dockerfile that contains the instructions for building the Docker image.
Favicon folder: The folder that contains the favicon for the application.

Step 1: Create an S3 Bucket

To create an S3 bucket, follow these steps:

Open the AWS Management Console and navigate to the S3 service.
Click the Create bucket button to create a new bucket.
Enter a unique name for your bucket and select the region where you want to create it. Then click on the Create bucket button to create the bucket.

Figure 1: Enter a unique name for your bucket.

Once the bucket is created, click on the bucket name to open the bucket.

Figure 2: Bucket created.

Step 2: Configure Bucket for Static Website Hosting

To configure the bucket for static website hosting, follow these steps:

Click on the Properties tab and then click on the Static website hosting card.
Click on Edit and select the Enable option. Enter the name of the index document (e.g, index.html) and click on the Save changes button to save the changes.

Figure 3: Configure the bucket for static website hosting.

Step 3: Make the Bucket Public

To make the bucket public, follow these steps:

On the Permissions tab, click on the Block public access button and then click on the Edit button.

Figure 4: Block public access.

Uncheck the Block all public access option and click on the Save changes button.

Figure 5: Uncheck the block-all public access option.

Still on the Permissions tab, click on the Bucket Policy button.
Click Edit and enter the following bucket policy to make the bucket public. Replace your-bucket-name with the name of your bucket.

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Sid": "PublicReadGetObject",
         "Effect": "Allow",
         "Principal": "*",
         "Action": "s3:GetObject",
         "Resource": "arn:aws:s3:::your-bucket-name/*"
       }
     ]
   }

Click on the Save changes button to save the bucket policy.

Figure 6: Bucket policy.

Step 4: Upload Application Files to the Bucket

To upload the application files to the bucket, follow these steps:

On the Objects tab, click on the Upload button to upload the application files to the bucket.

Figure 7: Upload the application files to the bucket.

Click the Add files button and select the application files from your local machine. Then, click on Add folder to upload the favicon folder.

Figure 8: Add files to the bucket.

Click the Upload button to upload the files to the bucket.

Figure 9: Application files uploaded to the bucket.

Step 5: Access the Application

To access the application, follow these steps:

Open the bucket and click on the Properties tab.
Click on the Static website hosting card and copy the endpoint URL.

Figure 10: Copy the endpoint URL.

Open a web browser and paste the endpoint URL in the address bar.

Figure 11: Word counter application.

Clean Up

After deploying and playing around with your application, you can delete the S3 bucket to avoid incurring unnecessary charges.

To delete the S3 bucket, follow these steps:

On the word-counter bucket, select all the files and click on the Delete button to delete the files.
Afterward, go back to your bucket and click the Delete button to delete the bucket.

Conclusion

In this article, you learned about AWS S3 and how to deploy a word counter application to an S3 bucket.

You created an S3 bucket, configured it for static website hosting, uploaded the application files to the bucket, and accessed the application using a web browser.

This is a simple and fast way of hosting static websites on AWS!

How to Setup an Integrated Development Environment on AWS

Nwokocha wisdom maduabuchi — Fri, 16 Feb 2024 17:56:54 +0000

It is common for development teams to be distributed all over the world, and this can create a significant problem when collaborating. Remote teams often have isolated development environments on each developer's laptop. In the event of a bug or a problem, a developer may spend hours trying to fix it, whereas another team member may be able to resolve it more quickly.

It is often difficult for team members to collaborate in the traditional paradigm of local IDEs due to geographical constraints and isolation. An effective solution to this problem is to create a shared development environment. It should be accessible to all team members, regardless of their location. This is where cloud-based IDEs come in.

Cloud9 is an AWS-developed IDE service that lets developers collaborate on a single codebase using cloud technology At the end of this article, you will learn how developers can collaborate on a single codebase using Cloud9.

What is Cloud9?

AWS Cloud9 is a browser-based development environment that is backed by an Amazon EC2 instance. It provides a user with a complete environment including an editor, terminal, and terminal in the cloud.

A variety of programming languages are also available, including Python, JavaScript, PHP, and more. With Cloud9, you can work with your team members in real time. Your team members can also work on the same codebase by sharing a development environment.

Why Cloud9?

Apart from sharing environments for quick collaboration and pair coding, these are some reasons why you should consider using Cloud9:

Quick setup time: Setting up a development environment on Cloud9 is quick and easy. You can set up and configure your development environment in minutes.
Limited Maintenance: Cloud9 is a managed service, so you don't have to worry about maintaining the infrastructure. AWS takes care of the infrastructure, so you can focus on writing code.
Unlimited access: You're not tied to a single machine. You can access your development environment from any machine with an internet connection. Allowing you to work from anywhere.
Easy integration with AWS services: When you use AWS Cloud9, you can target AWS services such as AWS Lambda, pull code from AWS CodeCommit, and set up CI/CD pipelines with AWS CodePipeline.
Disposable environments: When carrying out tests or debugging, you can create a new environment and discard it when you're done. This helps to keep your development environment clean and organized.

Setting up Cloud9

This article will guide you through setting up a Cloud9 environment using the AWS console.

Prerequisites

To set up a Cloud9 environment, you will need the following:

An AWS account. If you don't have one, you can create one for free here.
Stable internet connection. Cloud9 is a cloud-based service, so you will need a stable internet connection to use it.
A fundamental knowledge of AWS and how to navigate the AWS Management Console. To get started, you can check out the AWS Management Console.

To create a Cloud9 environment using the AWS console, follow the steps below:

On AWS, navigate to the Cloud 9 console and click on the Create Environment button.
Fill in the form, specifying the Name, Instance type and Platform.
After which, click on the Create button.
After the Cloud9 environment is provisioned, you can open the IDE.
Under the Cloud9 IDE tab, click on Open to view the IDE.
Explore the Cloud9 IDE. Observe the similarities and differences between your conventional IDE and this one.

NOTE: Remember to destroy the environment and associated resources such as the IAM role when finished.

With this setup, you can share your codebase with your team members and collaborate in real time.

To create a Cloud9 environment for an entire team, you can create an IAM role with the necessary permissions and share the environment with the team members. Learn more about Cloud9 team environments here.

Conclusion

This article explains how to set up a Cloud9 environment via the AWS console. You have also learned about the benefits of using Cloud9 as a shared development environment.

You can extend this knowledge by automating this process with AWS CloudFormation. This will allow you to create and destroy Cloud9 environments on the fly.

Additionally, you could include configuration management tools such as Ansible to install and configure the necessary tools and libraries on the Cloud9 environment.

Building a Social Media App with AWS Amplify and Android Studio: A Step-by-Step Guide

Nwokocha wisdom maduabuchi — Fri, 31 Mar 2023 10:06:54 +0000

AWS Amplify is a popular development framework that enables developers to build scalable and secure cloud-powered applications. It simplifies the development process by providing a set of tools and services that allow developers to create high-quality mobile and web applications quickly. With AWS Amplify, developers can easily integrate cloud services into their applications, such as authentication, storage, APIs, and real-time data synchronization.

The purpose of this article is to provide a comprehensive, step-by-step guide to building a social media app using AWS Amplify and Android Studio. The article will explain how to set up Android Studio, add Amplify to the project, create a backend using the Amplify CLI, and implement authentication, storage, API services, and real-time data functionality using Amazon Cognito, Amazon S3, Amazon API Gateway, and Amazon AppSync. By the end of the article, readers will have a fully functional social media app that demonstrates the power and versatility of AWS Amplify and Android Studio.

Setting Up Development Environment

Downloading and installing Android Studio

Visit the Android Studio website (https://developer.android.com/studio) and click on the "Download Android Studio" button.
Choose the appropriate version for your operating system (Windows, macOS, or Linux) and click the "Download" button.
Once the download is complete, run the installer file and follow the instructions to install Android Studio on your computer.

Creating a new project:

Launch Android Studio and select "Start a new Android Studio project" from the main menu.
Choose the "Phone and Tablet" option and select the type of project you want to create, such as "Empty Activity" or "Basic Activity".
Set the name and package name for your project.
Choose the minimum SDK version and the target SDK version.
Select the language you want to use (Java or Kotlin).
Choose any additional features or services you want to include in your project.
Click "Finish" to create your project.

Congratulations! You have successfully installed Android Studio and created a new project.
In the next section, you will explore how to integrate AWS Amplify into your Android Studio project.

Integrating AWS Amplify into Android Studio Project

Open your project in Android Studio.
Navigate to the "app" folder in the project explorer.
Open the build.gradle file for your app module.
In the dependencies section, add the following line of code to include the AWS Amplify dependency:

implementation 'com.amplifyframework:core:1.8.1'

Click on the "Sync Now" button to sync the changes with your project.

Initializing Amplify in onCreate method of MainActivity.java file:

Open your MainActivity.java file.
Add the following import statement at the top of your file:

import com.amplifyframework.core.Amplify;

In the onCreate method of your MainActivity, add the following code to initialize AWS Amplify:

Amplify.configure(getApplicationContext());

This line of code initializes Amplify with the application context.

Congratulations! You have successfully added the AWS Amplify dependency to your build.gradle file and initialized it in your MainActivity.java file.
In the next section, we will explore how to create an AWS Amplify backend for your Android application.

Creating an AWS Amplify Backend

Open a terminal or command prompt and install the Amplify CLI by running the following command:

npm install -g @aws-amplify/cli

Once the installation is complete, initialize Amplify in your project directory by running the following command:

amplify init

Follow the prompts to configure your Amplify backend. Choose the appropriate options for your project, such as the AWS region, authentication type, and API type.
Once you have configured your backend, use the Amplify CLI to create the necessary resources by running the following command:

amplify push

This command creates the resources specified in your Amplify configuration file, such as authentication, API, and storage resources.

Configuring and deploying the backend:

After running the amplify push command, navigate to the Amplify console in the AWS Management Console.
Click on the "Backend environments" option in the left-hand menu and select your project.
Click on the "Backend environments" tab and click on the environment you want to deploy to.
Click on the "Deploy changes" button to deploy your backend resources to the selected environment.

Congratulations! You have successfully created an AWS Amplify backend for your Android application using the Amplify CLI and deployed it to the selected environment.
In the next section, we will explore how to use AWS Amplify to implement various cloud services in your Android application.

Using AWS Amplify in Android Studio

*Adding authentication to the application using Amazon Cognito:
*

Open your Amplify configuration file (amplify/backend/amplify-meta.json).
Add the following lines of code to the auth section to enable Amazon Cognito authentication:

"auth": {
  "plugins": {
    "awsCognitoAuthPlugin": {
      "userPoolId": "YOUR_USER_POOL_ID",
      "region": "YOUR_AWS_REGION",
      "userPoolWebClientId": "YOUR_USER_POOL_WEB_CLIENT_ID"
    }
  }
}

Replace the placeholders with your Amazon Cognito user pool ID, region, and user pool web client ID.
In your Android project, initialize the Amazon Cognito authentication by adding the following code in your MainActivity.java file:

Amplify.addPlugin(new AWSCognitoAuthPlugin());
Amplify.configure(getApplicationContext());

This code initializes the Amazon Cognito authentication plugin and configures Amplify with the application context.

Implementing storage using Amazon S3:

Open your Amplify configuration file.
Add the following lines of code to the storage section to enable Amazon S3 storage:

"storage": {
  "plugins": {
    "awsS3StoragePlugin": {
      "bucketName": "YOUR_BUCKET_NAME",
      "region": "YOUR_AWS_REGION"
    }
  }
}

Replace the placeholders with your Amazon S3 bucket name and region.
In your Android project, use the Amplify Storage API to upload and download files from Amazon S3. For example, to upload a file, add the following code:

File localFile = new File(getApplicationContext().getFilesDir(), "localFileName.jpg");
Amplify.Storage.uploadFile(
        "remoteFileName.jpg",
        localFile,
        result -> Log.i("MyAmplifyApp", "Successfully uploaded: " + result.getKey()),
        error -> Log.e("MyAmplifyApp", "Upload failed", error)
);

Using API services with Amazon API Gateway:

Open your Amplify configuration file.
Add the following lines of code to the api section to enable Amazon API Gateway:

"api": {
  "plugins": {
    "awsAPIPlugin": {
      "endpointType": "REST",
      "endpoint": "YOUR_API_ENDPOINT",
      "region": "YOUR_AWS_REGION"
    }
  }
}

Replace the placeholders with your Amazon API Gateway endpoint and region.
In your Android project, use the Amplify API category to interact with your API resources. For example, to fetch data from a resource, add the following code:

Amplify.API.get("resourceName", "/resourcePath", null,
        response -> Log.i("MyAmplifyApp", response.getData().asString()),
        error -> Log.e("MyAmplifyApp", "Failed to get resource data", error)
);

Displaying real-time data with Amazon AppSync:

Open your Amplify configuration file.
Add the following lines of code to the api section to enable Amazon AppSync:

"api": {
  "plugins": {
    "awsAPIPlugin": {
      "endpointType": "GraphQL",
      "endpoint": "YOUR_APPSYNC_API_ENDPOINT",
      "region": "YOUR_AWS_REGION"
    }
  }
}

Replace the placeholders with your Amazon AppSync API endpoint and region.
In your Android project, use the Amplify API category to subscribe to real-time data changes. For example, to listen for updates to a specific resource, add the following code:

Amplify.API

Using API Services

Create a new REST API in the Amazon API Gateway console
Go to the Amazon API Gateway console and click "Create API."
Choose "REST API" as the type of API to create.
Select "New API" and give your API a name.
Click "Create API."
Create a new resource
Click "Create Resource" under your newly created API.
Enter a name for your resource and click "Create Resource."
Create a new method for the resource
Select your newly created resource and click "Create Method."
Choose the type of method you want to create (e.g., GET, POST, PUT).
Select the integration type (e.g., Lambda Function, HTTP Proxy, Mock).
Configure the integration settings according to your specific use case.
Click "Save."
Deploy the API
Click "Actions" and select "Deploy API."
Choose the deployment stage (e.g., Prod, Test) and click "Deploy."
Use the API in your Android app
Open your Android Studio project and add the necessary dependencies to your app's build.gradle file.
Create a new instance of the Amazon API Gateway client and set the appropriate endpoint and API key.
Use the client to make requests to your API and receive responses back in your app.

By following these steps, you can easily set up Amazon API Gateway and add API services to your social media app using AWS Amplify and Android Studio.

Displaying Real-time Data

Create a new GraphQL API in the Amazon AppSync console
Go to the Amazon AppSync console and click "Create API."
Choose "Create with Wizard" and give your API a name.
Select "None" for data source and click "Create."
Define a GraphQL schema for your API
In the AppSync console, select your newly created API and click "Schema."
Define the data types and fields for your API using the GraphQL schema language.
Save your schema.
Create a new data source for your API
In the AppSync console, select your API and click "Data Sources."
Click "Create New Data Source" and select the appropriate data source type (e.g., Amazon DynamoDB, AWS Lambda).
Configure the data source settings according to your specific use case.
Click "Create."
Create a new resolver for your API
In the AppSync console, select your API and click "Resolvers."
Click "Create Resolver" and select the appropriate data source and field.
Define the resolver mapping template using the appropriate AppSync resolver syntax.
Save your resolver.
Add real-time data functionality to your app
Open your Android Studio project and add the necessary dependencies to your app's build.gradle file.
Create a new instance of the Amazon AppSync client and set the appropriate endpoint and API key.
Subscribe to the appropriate GraphQL subscription in your app's code to receive real-time updates from your API.

By following these steps, you can easily set up Amazon AppSync and add real-time data functionality to your social media app using AWS Amplify and Android Studio.

Testing the App

After developing your social media app with AWS Amplify and Android Studio, you can run and test it on an Android device or emulator using the following steps:

Connect your Android device or start an emulator
Connect your Android device to your computer using a USB cable, or start an emulator using Android Studio's AVD Manager.
Build and run your app in Android Studio
Click the "Run" button in Android Studio or select "Run" from the "Run" menu.
Select your Android device or emulator from the list of available devices and click "OK."
Android Studio will build and install your app on the selected device or emulator.
Test the app's functionality
Open the app on your Android device or emulator.
Test the various features and functionality of your social media app, including authentication, storage, API services, and real-time data.
Verify that your app is working correctly and that all features are functioning as expected.
Debug any issues
If you encounter any issues while testing your app, use Android Studio's debugging tools to identify and fix the problem.
Use the Android Logcat window to view app logs and error messages.
Use the Android Debugging Bridge (ADB) to interact with your device or emulator and debug issues in real-time.

By following these steps, you can easily run and test your social media app on an Android device or emulator using AWS Amplify and Android Studio. This will ensure that your app is working correctly and that all features are functioning as expected before releasing it to your users.

Conclusion

In summary, using AWS Amplify with Android Studio for social media app development offers several benefits, including:

Simplified app development: AWS Amplify provides a set of pre-built services and features that can be easily integrated into your app, reducing the need for custom coding and streamlining app development.
Scalability and flexibility: AWS Amplify allows for easy scaling and customization of your app as your business needs change, allowing you to add new features and services as necessary.
Security and compliance: AWS Amplify provides built-in security and compliance features that help keep your app and user data safe and secure.
Real-time data: With Amplify's real-time data functionality, your social media app can provide instant updates and notifications to users, improving engagement and user experience.
Cloud-powered infrastructure: AWS Amplify leverages the power of cloud infrastructure, allowing for seamless data storage, fast data processing, and reliable performance

Building Cloud-Powered Android Applications with AWS Amplify and Android Studio

Nwokocha wisdom maduabuchi — Fri, 31 Mar 2023 09:49:03 +0000

In this article, we will explore how to use AWS Amplify with Android Studio, one of the most popular integrated development environments (IDEs) for Android app development. By the end of this article, you will have a good understanding of how to integrate AWS Amplify into your Android Studio project and use it to develop cloud-powered applications.

Setting Up Development Environment

Downloading and installing Android Studio

Visit the Android Studio website (https://developer.android.com/studio) and click on the "Download Android Studio" button.
Choose the appropriate version for your operating system (Windows, macOS, or Linux) and click the "Download" button.
Once the download is complete, run the installer file and follow the instructions to install Android Studio on your computer.

Creating a new project:

Launch Android Studio and select "Start a new Android Studio project" from the main menu.
Choose the "Phone and Tablet" option and select the type of project you want to create, such as "Empty Activity" or "Basic Activity".
Set the name and package name for your project.
Choose the minimum SDK version and the target SDK version.
Select the language you want to use (Java or Kotlin).
Choose any additional features or services you want to include in your project.
Click "Finish" to create your project.

Congratulations! You have successfully installed Android Studio and created a new project.
In the next section, you will explore how to integrate AWS Amplify into your Android Studio project.

Integrating AWS Amplify into Android Studio Project

Open your project in Android Studio.
Navigate to the "app" folder in the project explorer.
Open the build.gradle file for your app module.
In the dependencies section, add the following line of code to include the AWS Amplify dependency:

implementation 'com.amplifyframework:core:1.8.1'

Click on the "Sync Now" button to sync the changes with your project.

Initializing Amplify in onCreate method of MainActivity.java file:

Open your MainActivity.java file.
Add the following import statement at the top of your file:

import com.amplifyframework.core.Amplify;

In the onCreate method of your MainActivity, add the following code to initialize AWS Amplify:

Amplify.configure(getApplicationContext());

This line of code initializes Amplify with the application context.

Creating an AWS Amplify Backend

Open a terminal or command prompt and install the Amplify CLI by running the following command:

npm install -g @aws-amplify/cli

Once the installation is complete, initialize Amplify in your project directory by running the following command:

amplify init

Follow the prompts to configure your Amplify backend. Choose the appropriate options for your project, such as the AWS region, authentication type, and API type.
Once you have configured your backend, use the Amplify CLI to create the necessary resources by running the following command:

amplify push

This command creates the resources specified in your Amplify configuration file, such as authentication, API, and storage resources.

Configuring and deploying the backend:

After running the amplify push command, navigate to the Amplify console in the AWS Management Console.
Click on the "Backend environments" option in the left-hand menu and select your project.
Click on the "Backend environments" tab and click on the environment you want to deploy to.
Click on the "Deploy changes" button to deploy your backend resources to the selected environment.

Using AWS Amplify in Android Studio

*Adding authentication to the application using Amazon Cognito:
*

Open your Amplify configuration file (amplify/backend/amplify-meta.json).
Add the following lines of code to the auth section to enable Amazon Cognito authentication:

"auth": {
  "plugins": {
    "awsCognitoAuthPlugin": {
      "userPoolId": "YOUR_USER_POOL_ID",
      "region": "YOUR_AWS_REGION",
      "userPoolWebClientId": "YOUR_USER_POOL_WEB_CLIENT_ID"
    }
  }
}

Replace the placeholders with your Amazon Cognito user pool ID, region, and user pool web client ID.
In your Android project, initialize the Amazon Cognito authentication by adding the following code in your MainActivity.java file:

Amplify.addPlugin(new AWSCognitoAuthPlugin());
Amplify.configure(getApplicationContext());

This code initializes the Amazon Cognito authentication plugin and configures Amplify with the application context.

Implementing storage using Amazon S3:

Open your Amplify configuration file.
Add the following lines of code to the storage section to enable Amazon S3 storage:

"storage": {
  "plugins": {
    "awsS3StoragePlugin": {
      "bucketName": "YOUR_BUCKET_NAME",
      "region": "YOUR_AWS_REGION"
    }
  }
}

Replace the placeholders with your Amazon S3 bucket name and region.
In your Android project, use the Amplify Storage API to upload and download files from Amazon S3. For example, to upload a file, add the following code:

File localFile = new File(getApplicationContext().getFilesDir(), "localFileName.jpg");
Amplify.Storage.uploadFile(
        "remoteFileName.jpg",
        localFile,
        result -> Log.i("MyAmplifyApp", "Successfully uploaded: " + result.getKey()),
        error -> Log.e("MyAmplifyApp", "Upload failed", error)
);

Using API services with Amazon API Gateway:

Open your Amplify configuration file.
Add the following lines of code to the api section to enable Amazon API Gateway:

"api": {
  "plugins": {
    "awsAPIPlugin": {
      "endpointType": "REST",
      "endpoint": "YOUR_API_ENDPOINT",
      "region": "YOUR_AWS_REGION"
    }
  }
}

Replace the placeholders with your Amazon API Gateway endpoint and region.
In your Android project, use the Amplify API category to interact with your API resources. For example, to fetch data from a resource, add the following code:

Amplify.API.get("resourceName", "/resourcePath", null,
        response -> Log.i("MyAmplifyApp", response.getData().asString()),
        error -> Log.e("MyAmplifyApp", "Failed to get resource data", error)
);

Displaying real-time data with Amazon AppSync:

Open your Amplify configuration file.
Add the following lines of code to the api section to enable Amazon AppSync:

"api": {
  "plugins": {
    "awsAPIPlugin": {
      "endpointType": "GraphQL",
      "endpoint": "YOUR_APPSYNC_API_ENDPOINT",
      "region": "YOUR_AWS_REGION"
    }
  }
}

Replace the placeholders with your Amazon AppSync API endpoint and region.
In your Android project, use the Amplify API category to subscribe to real-time data changes. For example, to listen for updates to a specific resource, add the following code:

Amplify.API

Conclusion

In summary, AWS Amplify provides developers with an easy and efficient way to build cloud-powered applications by simplifying the process of integrating and managing various AWS services. With Android Studio as the IDE, developers can easily implement Amplify and leverage its benefits to create high-performing and scalable applications.

By following the steps outlined in this guide, developers can add authentication, storage, API services, and real-time data to their Android applications using Amazon Cognito, Amazon S3, Amazon API Gateway, and Amazon AppSync, respectively.

Using AWS Amplify can significantly reduce the time and effort required to integrate various cloud services, allowing developers to focus more on building core features and functionality of their applications. Moreover, Amplify provides seamless scalability, robust security, and cost-effectiveness for cloud-powered application development.

We encourage developers to explore and experiment with the various AWS Amplify services and features available, as it can open up new possibilities and opportunities for creating innovative and dynamic applications. With the extensive documentation and support provided by AWS, developers can easily get started with Amplify and take their applications to the next level.

Building Cloud-Powered Android Applications with AWS Amplify and Android Studio

Nwokocha wisdom maduabuchi — Fri, 31 Mar 2023 09:40:46 +0000

AWS Amplify Kotlin is a popular development framework that enables developers to build scalable and secure cloud-powered applications. It simplifies the development process by providing a set of tools and services that allow developers to create high-quality mobile and web applications quickly. With AWS Amplify, developers can easily integrate cloud services into their applications, such as authentication, storage, APIs, and real-time data synchronization.

Setting Up Development Environment

Downloading and installing Android Studio

Visit the Android Studio website (https://developer.android.com/studio) and click on the "Download Android Studio" button.
Choose the appropriate version for your operating system (Windows, macOS, or Linux) and click the "Download" button.
Once the download is complete, run the installer file and follow the instructions to install Android Studio on your computer.

Creating a new project:

Launch Android Studio and select "Start a new Android Studio project" from the main menu.
Choose the "Phone and Tablet" option and select the type of project you want to create, such as "Empty Activity" or "Basic Activity".
Set the name and package name for your project.
Choose the minimum SDK version and the target SDK version.
Select the language you want to use (Java or Kotlin).
Choose any additional features or services you want to include in your project.
Click "Finish" to create your project.

Congratulations! You have successfully installed Android Studio and created a new project.
In the next section, you will explore how to integrate AWS Amplify into your Android Studio project.

Integrating AWS Amplify into Android Studio Project

Open your project in Android Studio.
Navigate to the "app" folder in the project explorer.
Open the build.gradle file for your app module.
In the dependencies section, add the following line of code to include the AWS Amplify dependency:

implementation 'com.amplifyframework:core:1.8.1'

Click on the "Sync Now" button to sync the changes with your project.

Initializing Amplify in onCreate method of MainActivity.java file:

Open your MainActivity.java file.
Add the following import statement at the top of your file:

import com.amplifyframework.core.Amplify;

In the onCreate method of your MainActivity, add the following code to initialize AWS Amplify:

Amplify.configure(getApplicationContext());

This line of code initializes Amplify with the application context.

Creating an AWS Amplify Backend

Open a terminal or command prompt and install the Amplify CLI by running the following command:

npm install -g @aws-amplify/cli

Once the installation is complete, initialize Amplify in your project directory by running the following command:

amplify init

Follow the prompts to configure your Amplify backend. Choose the appropriate options for your project, such as the AWS region, authentication type, and API type.
Once you have configured your backend, use the Amplify CLI to create the necessary resources by running the following command:

amplify push

This command creates the resources specified in your Amplify configuration file, such as authentication, API, and storage resources.

Configuring and deploying the backend:

After running the amplify push command, navigate to the Amplify console in the AWS Management Console.
Click on the "Backend environments" option in the left-hand menu and select your project.
Click on the "Backend environments" tab and click on the environment you want to deploy to.
Click on the "Deploy changes" button to deploy your backend resources to the selected environment.

Using AWS Amplify in Android Studio

*Adding authentication to the application using Amazon Cognito:
*

Open your Amplify configuration file (amplify/backend/amplify-meta.json).
Add the following lines of code to the auth section to enable Amazon Cognito authentication:

"auth": {
  "plugins": {
    "awsCognitoAuthPlugin": {
      "userPoolId": "YOUR_USER_POOL_ID",
      "region": "YOUR_AWS_REGION",
      "userPoolWebClientId": "YOUR_USER_POOL_WEB_CLIENT_ID"
    }
  }
}

Replace the placeholders with your Amazon Cognito user pool ID, region, and user pool web client ID.
In your Android project, initialize the Amazon Cognito authentication by adding the following code in your MainActivity.java file:

Amplify.addPlugin(new AWSCognitoAuthPlugin());
Amplify.configure(getApplicationContext());

This code initializes the Amazon Cognito authentication plugin and configures Amplify with the application context.

Implementing storage using Amazon S3:

Open your Amplify configuration file.
Add the following lines of code to the storage section to enable Amazon S3 storage:

"storage": {
  "plugins": {
    "awsS3StoragePlugin": {
      "bucketName": "YOUR_BUCKET_NAME",
      "region": "YOUR_AWS_REGION"
    }
  }
}

Replace the placeholders with your Amazon S3 bucket name and region.
In your Android project, use the Amplify Storage API to upload and download files from Amazon S3. For example, to upload a file, add the following code:

File localFile = new File(getApplicationContext().getFilesDir(), "localFileName.jpg");
Amplify.Storage.uploadFile(
        "remoteFileName.jpg",
        localFile,
        result -> Log.i("MyAmplifyApp", "Successfully uploaded: " + result.getKey()),
        error -> Log.e("MyAmplifyApp", "Upload failed", error)
);

Using API services with Amazon API Gateway:

Open your Amplify configuration file.
Add the following lines of code to the api section to enable Amazon API Gateway:

"api": {
  "plugins": {
    "awsAPIPlugin": {
      "endpointType": "REST",
      "endpoint": "YOUR_API_ENDPOINT",
      "region": "YOUR_AWS_REGION"
    }
  }
}

Replace the placeholders with your Amazon API Gateway endpoint and region.
In your Android project, use the Amplify API category to interact with your API resources. For example, to fetch data from a resource, add the following code:

Amplify.API.get("resourceName", "/resourcePath", null,
        response -> Log.i("MyAmplifyApp", response.getData().asString()),
        error -> Log.e("MyAmplifyApp", "Failed to get resource data", error)
);

Displaying real-time data with Amazon AppSync:

Open your Amplify configuration file.
Add the following lines of code to the api section to enable Amazon AppSync:

"api": {
  "plugins": {
    "awsAPIPlugin": {
      "endpointType": "GraphQL",
      "endpoint": "YOUR_APPSYNC_API_ENDPOINT",
      "region": "YOUR_AWS_REGION"
    }
  }
}

Replace the placeholders with your Amazon AppSync API endpoint and region.
In your Android project, use the Amplify API category to subscribe to real-time data changes. For example, to listen for updates to a specific resource, add the following code:

Amplify.API

Conclusion

The beauty of Retrofit 2.6.0 with Coroutines support

Nwokocha wisdom maduabuchi — Thu, 09 Apr 2020 18:53:39 +0000

Hello Dev,
I will be teaching you how to build a simple project using Retrofit 2.6.0 with its inbuilt support for Coroutines, this will help you to achieve better performance and reduces boilerplate codes significantly. 😍😍😍😍🥰🔥🔥

Note:

This tutorial assumes that you are familiar with the basics of the Retrofit library. If you are completely new to Retrofit, I advise you to read through http://www.kotlincodes.com/kotlin/retrofit-with-kotlin/ first.

New:

Retrofit 2.6. 0 has been released with support for suspend functions. This allows you to express the asynchrony of HTTP requests in an idiomatic fashion for the Kotlin language.

@GET("users/{id}")
suspend fun user(@Path("id") id: Long): User

Behind the scenes this behaves as if defined as fun user(...): Call and then invoked with Call.enqueue. You can also return Response for access to the response metadata.
follow up threads on the Retrofit release: https://github.com/square/retrofit/blob/master/CHANGELOG.md

What is the purpose of this article
1: learn how to build clean, readable and maintainable code
2: learn how to work with retrofit 2.6.0
3: learn how to work with MVVM architecture
4: learn how to work with a repository pattern

In this article I will be using an app I built for learning purposes called " Wammy ", the application is written in Kotlin and it uses MVVM, implemented repository, view model, live data and real-time internet connectivity check.

Alright lets 👀👀👀

First steps we are to add the necessary Dependencies

Build.gradle(module: app)


dependencies {
    def lifecycle_version = "2.3.0-alpha01"
    def arch_version = "2.1.0"
    def activity_version = "1.2.0-alpha02"

    implementation 'com.squareup.retrofit2:converter-gson:2.6.0'
    implementation 'com.squareup.retrofit2:retrofit:2.6.0'
    kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
    implementation 'com.github.wise4rmgod:AdnetwrokManager:0.1.0'
    // Kotlin
    implementation "androidx.activity:activity-ktx:$activity_version"
    // Lifecycles only (without ViewModel or LiveData)
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"
    // ViewModel
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.3.0-alpha01'
    // LiveData
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
    // Coroutines
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2"

}

The second step is to know the API Endpoint to work with, in this example we will work :

GET https://jsonplaceholder.typicode.com/posts

the Endpoint will return

[
  {
    "userId": 1,
    "id": 1,
    "title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
    "body": "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto"
  }
]

The third step is to create a Retrofit interface. in this example, it will be


interface Webservice {
    @GET("/posts")
    suspend fun getTodo(): Todou
}

After that let's implement the Retrofit builder that will return our webservice:

class RetrofitClient {
    companion object {
        val retrofit = Retrofit.Builder()
            .baseUrl(Constant.BASE_URL)
            .addConverterFactory(GsonConverterFactory.create(GsonBuilder().create()))
            .build().create(Webservice::class.java)
    }
}

The next step is to create the Repository class which creates the instance of the retrofit service and initiates the API call, our method for this call should be a suspend function as it will later be called through a coroutine.

class TodoRepository {

    var client: Webservice = RetrofitClient.retrofit

    suspend fun getTodo() = client.getTodo()
}

Now that our repository is set up we can create a method in the ViewModel which uses the liveData builder to create a process on the IO thread.

class TodoViewmodel : ViewModel() {
    val repository: TodoRepository = TodoRepository()

    val firstTodo: LiveData<Todou> = liveData(Dispatchers.IO) {
        val retrivedTodo = repository.getTodo()
        emit(retrivedTodo)
    }

}

The emit function emits the changes in the underlying database to the observer variables, in our case which will be located in the MainActivity.

val viewModel: TodoViewmodel by viewModels()
    private lateinit var binding: ActivityMainBinding
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        gotonextativity()
        checknetworkstatus()

    }

    private fun checknetworkstatus() {
        CheckNetworkStatus.getNetworkLiveData(applicationContext).observe(this, Observer { t ->
            when (t) {
                true -> {
                    showdummy()
                }
                false -> {
                    Toast.makeText(this, "No Network Connection", Toast.LENGTH_SHORT).show()
                }
                null -> {
                    // TODO: Handle the connection...
                }
            }
        })
    }

    private fun showdummy() {
        viewModel.firstTodo.observe(this, Observer { t ->
            binding.recyclerView.adapter =
                DummyAdapter(t, applicationContext)
            binding.recyclerView.adapter?.notifyDataSetChanged()
        })
    }

    }
}

we can see the observer observing the value of t from the API and updating the UI accordingly.

Hurray!!! your code is cleaner, readable and leverages the coroutine support.
Thanks for your time 🥰🔥🔥
follow me on Twitter: https://twitter.com/Joklinztech
full project Github: https://github.com/wise4rmgod/Wammy

Build small-sized apps using ProGuard

Nwokocha wisdom maduabuchi — Sat, 04 Apr 2020 19:39:52 +0000

It's important to enable proguard in our project, so if a question arises in the form "should all android apps enable proguard?" I will say yes.
Because you will build a small-sized app, unused code removed and all identifiers changed to protect from decompiling apk.

What is ProGuard

ProGuard is a tool that shrinks, optimizes and obfuscates code, it is readily available as part of the Android Gradle build process and ships with the SDK.

Why Proguard

1: it gets rid of unused code
2: it renames identifiers to make the code smaller,
3: it performs the whole program optimizations.

Note:

However, when you create a new project using Android Studio, shrinking, obfuscation, and code optimization is not enabled by default. That’s because these compile-time optimizations increase the build time of your project and might introduce bugs if you do not sufficiently
So, it’s best to enable these compile-time tasks when building the final version of your app that you test prior to publishing. To enable shrinking, obfuscation, and optimization, you will include the following in your project-level build.gradle file.

How to Setup Proguard


android {
    buildTypes {
        release {
            // Enables code shrinking, obfuscation, and optimization for only
            // your project's release build type.
            minifyEnabled true

            // Enables resource shrinking, which is performed by the
            // Android Gradle plugin.
            shrinkResources true

            // Includes the default ProGuard rules files that are packaged with
            // the Android Gradle plugin. To learn more, go to the section about
            // R8 configuration files.
            proguardFiles getDefaultProguardFile(
                    'proguard-android-optimize.txt'),
                    'proguard-rules.pro'
        }
    }
    ...
}

Conclusion:
When you use ProGuard you should always QA your release builds thoroughly, either by having end-to-end tests or manually going through all screens in your app to see if anything is missing or crashing.
also, some Libraries include Proguard/R8 guide to help protect some of the classes created to avoid missing classes example Retrofit

UI Testing with Espresso in Android Studio

Nwokocha wisdom maduabuchi — Thu, 19 Mar 2020 10:27:37 +0000

User interface (UI) testing lets you ensure that your app meets its functional requirements and achieves a high standard of quality such that it is more likely to be successfully adopted by users.

The Espresso testing framework, provided by AndroidX Test, provides APIs for writing UI tests to simulate user interactions within a single target app. Espresso tests can run on devices running Android 2.3.3 (API level 10) and higher, also The Espresso testing framework is an instrumentation-based API and works with the AndroidJUnitRunner test runner.
UI testing using Espresso Test Recorder is very good because it will take the pain of writing the test manually.

BENEFITS OF ESPRESSO

1) Saves time writing UI test

2) it's not error-prone

3) it automates the test

4) it's maintained by the Android team

5) it's not tedious

6) it's easy to use

7) write concise, beautiful, and reliable Android UI tests

API components

The main components of the Espresso include the following:

Espresso

Entry point to interactions with views (via onView() and onData()). It also exposes APIs that are not necessarily tied to any view, such as pressBack().

ViewMatchers

A collection of objects that implement the Matcher<? super View> interface. You can pass one or more of these to the onView() method to locate a view within the current view hierarchy.

ViewActions

A collection of ViewAction objects that can be passed to the ViewInteraction.perform() method, such as click().

ViewAssertions

A collection of ViewAssertion objects that can be passed the ViewInteraction.check() method. Most of the time, you will use the matches assertion, which uses a View matcher to assert the state of the currently selected view.

NOTE: An assertion: is the core of your test. It's a code statement that checks that your code or app behaved as expected.

HOW IT WORKS

Set up Espresso

dependencies {
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.0'
}

In the video, I explained how to write a simple UI test using an espresso test recorder in an Android studio.

Video: https://youtu.be/22MZXJFMq98

For more info: https://developer.android.com/training/testing/espresso
and https://developer.android.com/training/testing/espresso/basics

How to add the DayNight Theme to an Android app using Kotlin

Nwokocha wisdom maduabuchi — Tue, 10 Mar 2020 19:17:30 +0000

The DayNight functionality in AppCompat allows your app to easily switch between a dark ⚫ and light ⚪ theme.
Also, the DayNight theme gives an app the cool capability of switching color schemes based on the time of day and the device's last known location.

Benefits of DayNight Theme

1: Saves battery life
2: reduce the risk of damaging the eyes
3: easily accessible at night
4: increasing usability for people with reduced-vision

Learn to use Androidx DayNight Theme

Step 1 ) Update styles.xml

<style name="AppTheme" parent="Theme.AppCompat.DayNight.DarkActionBar">

The themes you can extend from to add day night theme switching capability are the following:

"Theme.AppCompat.DayNight"
"Theme.AppCompat.DayNight.NoActionBar"
"Theme.AppCompat.DayNight.DarkActionBar"

Step 2 ) Update MainActivity code

To switch the theme, call the AppCompatDelegate.setDefaultNightMode(int) method from your Kotlin code. (This will change the color scheme for the whole app, not just any one activity or fragment.) For example:

AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)

Note:

AppCompatDelegate.MODE_NIGHT_NO:
this sets the default theme for your app and takes the colors defined in the res/values directory. It is recommended to use light colors for this theme.

AppCompatDelegate.MODE_NIGHT_YES:
this sets a night theme for your app and takes the colors defined in the res/values-night directory. It is recommended to use dark colors for this theme.

AppCompatDelegate.MODE_NIGHT_AUTO:
this auto switches the colors of the app based on the time of the day and the colors you have defined in values and values-night directories.

Note:

however, that the theme switch will not persist if you kill the app and reopen it. If you do that, the theme will switch back to AppCompatDelegate.MODE_NIGHT_AUTO, which is the default value. If you want the theme switch to persist, make sure you store the value in shared preferences and load the stored value each time the app is opened after it has been destroyed.

GitHub

Understanding Memory Leaks in Android Developments.

Nwokocha wisdom maduabuchi — Mon, 09 Mar 2020 18:15:25 +0000

Imagine living in an apartment with your little waste bin outside, a bit close to the sitting room window. But every time the garbage truck/collectors come around, they skip emptying your waste bin. With each passing day your waste bin gets fuller and more smelly, the pungent smell may discourage you from laying on the sitting room couch. Then one day you decide to do something about your waste, you move your waste bin further to where it could be seen and picked up easily. Finally, your waste gets disposed and you can once again breathe a breath of fresh air.

This is exactly how a memory leak on an android app works. A memory leak occurs due to flimsy mistakes made while coding. And if an app has a memory leakage, the garbage collector can’t clear the heaps. Thereby causing the app to consume more memory which often leads to you receiving an error message stating; “ OutOfMemoryError”.

What is a Memory leak?

A memory leak is a programming error that causes an application to keep a reference to an object that is no longer needed. As a result, the memory allocated for that object cannot be reclaimed, eventually leading to an OutOfMemoryError crash.

One of the core benefits of Java is automated memory management with the help of the built-in Garbage Collector (or GC for short). Now you might want to ask what is a Garbage Collector and its function.

What Is A Garbage Collector?

The garbage collector is a program which runs on the Java Virtual Machinewhich gets rid of objects which are not being used by a Java application anymore. It is a form of automatic memory management.

The garbage collector will look for objects which aren’t being used anymore and gets rid of them, freeing up the memory so other new objects can use that piece of memory.

In Java, memory management is taken care of by the garbage collector, but in other languages such as C, one needs to perform memory management on their own using functions such as malloc and free. Memory management is one of those things which are easy to make mistakes, which can lead to what is called memory leaks — places where memory is not reclaimed when they are not in use anymore.

Automatic memory management schemes like garbage collection make it so the programmer does not have to worry so much about memory management issues, so he or she can focus more on developing the applications they need to develop.

So what are some of the common mistakes that lead to memory leaks?

Broadcast Receivers: Consider this scenario — you need to register a local broadcast receiver in your activity. If you don’t unregister the broadcast receiver, then it still holds a reference to the activity, even if you close the activity.

How to solve this? Always remember to call unregister receiver in onStop() of the activity.

Static Activity or View Reference: You are declaring a TextView as static (for whatever reason). If you reference activity or view directly or indirectly from a static reference, the activity would not be garbage collected after it is destroyed.

How to solve this? Always remember to NEVER use static variables for views or activities or contexts.

NOTE:
Always stop what you started in a program.

How to find a memory leak in our project.

1: Android profiler in android studio
2: LeakyCanary android library.

Unit Testing using Robolectric in Android Studio

Nwokocha wisdom maduabuchi — Sun, 05 Jan 2020 17:17:13 +0000

Unit testing is important because it is one of the earliest testing efforts performed on the code and the earlier defects are detected, the easier they are to fix. Early bug-detection is also the most cost-effective for a project, with code fixes becoming more expensive the later they're found in the lifecycle.

What is Unit Testing

UNIT TESTING is a level of software testing where individual units/ components of the software are tested. The purpose is to validate that each unit of the software performs as designed. A unit is the smallest testable part of any software. It usually has one or a few inputs and usually a single output.

Furthermore, Unit tests are the fundamental tests in your app testing strategy. By creating and running unit tests against your code, you can easily verify that the logic of individual units is correct. Running unit tests after every build help you to quickly catch and fix software regressions introduced by code changes to your app.

Two types of automated unit testing in android

Local tests:

Unit tests run on your local machine only. These tests are compiled to run locally on the Java Virtual Machine (JVM) to minimize execution time. If your tests depend on objects in the Android framework, we recommend using Robolectric. For tests that depend on your own dependencies, use mock objects to emulate your dependencies' behavior.

Instrumented tests:

Unit tests run on an Android device or emulator. These tests have access to instrumentation information, such as the Context for the app under test. Use this approach to run unit tests that have complex Android dependencies that require a more robust environment, such as Robolectric.

Benefits of Unit Testing

The goal of unit testing is to segregate each part of the program and test that the individual parts are working correctly. It isolates the smallest piece of testable software from the remainder of the code and determines whether it behaves exactly as you expect.

Unit testing provides numerous benefits including finding software bugs early, facilitating change, simplifying integration, and many others, which we will look right now with more detail.

1. Quality of Code
Unit testing improves the quality of the code. It identifies every defect that may have come up before code is sent further for integration testing. Writing tests before actual coding makes you think harder about the problem. It exposes the edge cases and makes you write better code.

2. Finds Software Bugs Early
Issues are found at an early stage. Since unit testing is carried out by developers who test individual code before integration, issues can be found very early and can be resolved then and there without impacting the other pieces of the code.

3. Facilitates Changes and Simplifies Integration
Unit testing reduces defects in the newly developed features or reduces bugs when changing the existing functionality.

4. Debugging Process
Unit testing helps simplify the debugging process. If a test fails, then only the latest changes made in the code need to be debugged.

5. Design
Writing the test first forces you to think through your design and what it must accomplish before you write the code. This not only keeps you focused; it makes you create better designs. Testing a piece of code forces you to define what that code is responsible for.

6. Reduce Costs
Since the bugs are found early, unit testing helps reduce the cost of bug fixes. Just imagine the cost of a bug found during the later stages of development, like during system testing or during acceptance testing. Of course, bugs detected earlier are easier to fix because bugs detected later are usually the result of many changes, and you don’t really know which one caused the bug.

Running unit test with Robolectric

Robolectric, it is a unit testing framework that allows Android applications to be tested on the JVM without an emulator

Reason to write unit test with Robolectric

1 It provides a way to run our tests inside Android Studio, without launching an app on Device or Emulator.

2 Shadow Classes, rewritten android core libraries by Robolectric, are the real magic of Robolectric. It is a replica of the Android class with some exposed useful functions. Cool, isn’t it?

3 You can test on Android components like:

Activity

Services

Broadcast Receiver

On app resources like:

Localization from strings.xml

Configuration like Landscape or Portrait

Styles and themes

And also for:
Multiple product flavors

How to integrate Robolectric in Android Studio?

Step 1

Add following dependencies in Gradle:

testOptions {
        unitTests {
            includeAndroidResources = true
        }
    }

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile 'com.android.support:appcompat-v7:25.2.0'
    testCompile 'junit:junit:4.12'
    testCompile 'org.robolectric:robolectric:3.2.2'
}

Now, let add UI Button and TextView into our app’s main screen. Following illustrates how our XML codes look like:

<?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"
    tools:context=".ui.last_step.LastStepActivity">


 <Button
            android:id="@+id/laststepfinishbtn"
            android:layout_width="match_parent"
            android:layout_height="50dp"
            android:background="@drawable/roundedgeeditext"
            android:text="Finish"
            android:textColor="@color/white" />

</android.support.constraint.ConstraintLayout>

The MainActivity class

public class MainActivity extends AppCompatActivity {

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


laststepfinishbtn.setOnClickListener {
            val intent =
                Intent(applicationContext, HomeActivity::class.java)

            startActivity(intent)
        }

    }


}

we have to create tests:
There are 3 folders in-app folder > src directory named
androidTest
main
test
We will add all our tests at test > java > [Your Package Name]. It’s standard practice to keep the same project structure of both the main and test folders. It will easy for us to track. Now create MainActivityTest class like this:


@RunWith(RobolectricTestRunner::class)
@Config(manifest = Config.NONE)
class MainActivityTest {
    @Test
    fun taketosigninactivity() {
        val activity = Robolectric.setupActivity(LastStepActivity::class.java)
        activity.laststepfinishbtn.performClick()
        val intent = Shadows.shadowOf(activity).peekNextStartedActivity()
        Assert.assertEquals(
            HomeActivity::class.java.canonicalName,
            intent.component!!.className
        )

    }
}

Terms and there meaning:

*assertTrue:
you are asserting that the expression is true. If it is not, then it will display the message and the assertion will fail.

assertTrue("TextView contains incorrect text",
            "Hello world!".equals(tvHelloWorld.getText().toString()));

*assertFalse:
you are asserting that an expression evaluates to false. If it is not, then the message is displayed and the assertion fails.

assertFalse("TextView contains incorrect text",
            "Hello world!".equals(tvHelloWorld.getText().toString()));

*assertNotnull:
you are asserting that the expression is not empty. If it is not, then it will display the message and the assertion will fail.

 assertNotNull("TextView is null", textView);

*shadows:
Shadows are classes that modify or extend the behavior of classes in the Android SDK. Most of the Android core views are built with shadow classes to avoid needing the device or an emulator to run

 val intent = Shadows.shadowOf(activity).peekNextStartedActivity()
        Assert.assertEquals(
            HomeActivity::class.java.canonicalName,
            intent.component!!.className
        )

Useful Link for Asserts methods

all Assert method

Congratulations you have written your first unit test using Robolectric Android library

9 Reasons to Use Kotlin Over Java for Android Development

Nwokocha wisdom maduabuchi — Thu, 26 Dec 2019 22:51:29 +0000

It's a big decision to make by moving from Java to Kotlin as your go-to language for your Android-based projects.

The biggest question now is " Why would you even consider trying Kotlin in your future mobile app projects? "

Here are the nine strongest reasons why, as an Android developer, you should start using a kotlin programming language to build your next Android project:

1: Kotlin the future of Android development

Kotlin is all set for a bright future in the Android app development eco-system. The lower cost of development and maintenance of Kotlin projects is a big plus for any business. It has a plethora of great language features and offers brevity that ensures higher quality with faster turn-around time.
Kotlin is the number one language to build an Android native app.

2: It's Completely Interoperable With Java

Kotlin is 100% interoperable with java means whenever two java and kotlin files exist together they can share data with each other.

While designing interoperability in kotlin, JetBrains makes major emphasis on Kotlin’s interaction with the existing Java code. The team makes sure that kotlin can easily and completely interact with the existing Java code. So that it can become easy for Java developers to migrate their Java project to Kotlin. There is also an automatic java-to-Kotlin converter in major IDEs for simplifies migration from Java to Kotlin.

3: It's More Concise Than Java

It means fewer opportunities for errors. Adopting Kotlin does not cost anything. Kotlin is compatible with all Java libraries and frameworks, the JVM (Java Virtual Machine) and can be integrated with Gradle or Maven build systems.
Yes, Kotlin makes programming easier and Android apps better. Kotlin is a modern programming language. It was created by JetBrains - a company that built the best Java IDE ever. They created Kotlin to address the weaknesses of existing languages.

4: It Has Null in Its Type System

Nullability issues have been one of Java's well-known sore points. Since it's a common thing in Android for the absence of certain values to be represented as “null,” Kotlin comes to address these issues by placing null right in its type system.

5: Kotlin has a strong community

JetBrains is constantly improving the language. It's committed to the project, has a large and highly competent team working on it, has a stable business model and is even converting parts of their own flagship product to use it.

6: its easier to write than Java

If you want to facilitate the product maintenance or streamline custom Android app development, you can assign two or three engineers to move the project to Kotlin starting from a small part of the codebase.

7: jetpack compose is built upon kotlin

Jetpack Compose simplifies and accelerates UI development on Android. Quickly bring your app to life with less code, powerful tools, and intuitive Kotlin APIs.
it's 100% Kotlin.