Androidians

How to Set Up Multiple GitHub Accounts in Android Studio Using SSH

noreply@blogger.com (androidians) — Thu, 28 May 2026 17:37:10 +0530

Managing multiple GitHub accounts on the same machine can be tricky, especially when switching between personal and work repositories. This guide explains how to configure multiple GitHub accounts using SSH in Android Studio and macOS/Linux terminals.

Step 1: Check Existing SSH Keys

Open Terminal and run:

ls -al ~/.ssh

This shows any existing SSH keys already present on your system.

Step 2: Generate SSH Key for First GitHub Account

Run:

ssh-keygen -t ed25519 -C "first-account@example.com" -f ~/.ssh/id_first

When prompted for a passphrase, you can press Enter twice to skip it.

Example output:

Generating public/private ed25519 key pair.
Your identification has been saved in ~/.ssh/id_first
Your public key has been saved in ~/.ssh/id_first.pub

Files Generated

File	Purpose
`~/.ssh/id_first`	Private key (Never share)
`~/.ssh/id_first.pub`	Public key (Add to GitHub)

Step 3: Generate SSH Key for Second GitHub Account

Run:

ssh-keygen -t ed25519 -C "second-account@example.com" -f ~/.ssh/id_second

Example output:

Your identification has been saved in ~/.ssh/id_second
Your public key has been saved in ~/.ssh/id_second.pub

Step 4: Add Both Keys to SSH Agent

Start SSH Agent

eval "$(ssh-agent -s)"

Add Both Keys

ssh-add ~/.ssh/id_first
ssh-add ~/.ssh/id_second

Verify Loaded Keys

ssh-add -l

You should see both SSH keys listed.

Step 5: Configure SSH

Open the SSH config file:

nano ~/.ssh/config

Add the following configuration:

# First GitHub Account
Host github-first
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_first
  AddKeysToAgent yes

# Second GitHub Account
Host github-second
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_second
  AddKeysToAgent yes

Save and exit:

Ctrl + O
Press Enter
Ctrl + X

Step 6: Add Public Keys to GitHub

First Account

Display the public key:

cat ~/.ssh/id_first.pub

Copy the entire output.

In GitHub:

Go to Settings
Open SSH and GPG Keys
Click New SSH Key
Paste the key
Save

Second Account

Display the second public key:

cat ~/.ssh/id_second.pub

Repeat the same steps in the second GitHub account.

Step 7: Test SSH Connections

First Account

ssh -T git@github-first

Expected output:

Hi username! You've successfully authenticated, but GitHub does not provide shell access.

Second Account

ssh -T git@github-second

Expected output:

Hi username! You've successfully authenticated, but GitHub does not provide shell access.

Step 8: Clone Repositories Using Host Alias

Clone Repository for First Account

git clone git@github-first:organization/repository.git

Clone Repository for Second Account

git clone git@github-second:username/repository.git

Important

Instead of using github.com, use the configured SSH aliases:

github-first
github-second

Step 9: Configure Git Identity Per Repository

After cloning the repository:

First Repository

cd first-repository/

git config user.name "Your Name"
git config user.email "first-account@example.com"

Second Repository

cd second-repository/

git config user.name "Your Name"
git config user.email "second-account@example.com"

Verify Configuration

git config --list | grep user

Step 10: Update Existing Repositories

If repositories were already cloned using github.com, update the remote URL.

Check Current Remote

git remote -v

Update Remote URL

First Account

git remote set-url origin git@github-first:organization/repository.git

Second Account

git remote set-url origin git@github-second:username/repository.git

Verify Updated Remote

git remote -v

Expected output:

origin  git@github-first:organization/repository.git (fetch)
origin  git@github-first:organization/repository.git (push)

Common Error

If you see:

fatal: No such remote 'origin'

Make sure you are running the command from inside the correct Git repository folder.

Final Notes

Using separate SSH keys and host aliases is the cleanest way to manage multiple GitHub accounts on the same machine. Once configured, Android Studio and Git automatically use the correct account for each repository.

This setup works well for:

Personal + Work GitHub accounts
Open-source contributions
Freelance projects
Multiple organizations
Secure repository management
Note: We can use any name for alias, here I use github-first and github-second. We can also use, github-office, github-personal etc. It is upto us.

Happy Exploring!!!

WorkManager Policies Demystified: KEEP vs CANCEL_AND_REENQUEUE vs UPDATE (With Real Example)

noreply@blogger.com (androidians) — Thu, 8 May 2025 12:42:00 +0530

When I first started using WorkManager in Android about five years ago, I had a lot of confusion—especially around configuring periodic workers. One of the biggest questions was:

Which ExistingPeriodicWorkPolicy should I use—KEEP, REPLACE, or something else?

Let me break it down with a simple example:

Suppose you schedule a periodic worker to run every 30 minutes. Later, you decide to change it to every 4 hours. Now, depending on the policy you choose, here’s what happens:

KEEP – The existing worker will continue running every 30 minutes. Your new 4-hour interval is ignored. So the old schedule stays.
REPLACE (now deprecated) – The current worker is cancelled and a new one is scheduled with the new interval. This is now replaced by a clearer version called CANCEL_AND_REENQUEUE, which behaves the same but has a more descriptive name.
UPDATE – This is a newer option. If the worker is currently running, it will finish using the old configuration. But from the next interval onwards, it will use your updated schedule. So it doesn’t interrupt what’s already happening, just updates what's coming next.

Knowing when and how these policies work can save you a lot of debugging time. For me, understanding this clearly made working with WorkManager much easier.

Happy exploring!!

Fetching Images from URLs in Jetpack Compose: Part 2 of the Login App

noreply@blogger.com (androidians) — Sun, 29 Sep 2024 19:01:00 +0530

In the first part of this series, I demonstrated how to populate images in our Jetpack Compose app using local resources from the drawable folder. In this article, we’ll take a step further and fetch images from URLs instead. To achieve this, we’ll use the Coil library, which simplifies image loading in Jetpack Compose.

Adding Coil to the Project

Since I’m using a Kotlin-based build.gradle file, adding the Coil dependency is straightforward. Here’s how you can include it in your project:


implementation(libs.coil.compose)

By using this approach, there’s no need to specify the version manually, as it is automatically handled by the dependencies management system.

Alternatively, if you prefer to add the dependency directly with a specific version, you can use:


implementation("io.coil-kt:coil-compose:2.1.0")

Either approach works, but managing dependencies via libs can help maintain cleaner and more organized build scripts.

Switching from Local to Remote Images

Previously, the images were stored locally in the app, and we were referencing them by their names. Now, we’ll modify the app to load images dynamically from URLs. The good news is that the process is straightforward using Coil, which integrates seamlessly with Jetpack Compose for loading images from the web.

However, one challenge arises when passing the image URL from the image list screen to the image details screen. Simply passing the URL directly as a parameter causes the app to crash with the following error:


java.lang.IllegalArgumentException: Navigation destination that matches request 
NavDeepLinkRequest{ uri=android-app://androidx.navigation/imageDetailsScreen
/image1/https://images.unsplash.com/photo-1506748686214-e9df14d4d9d0 } cannot 
be found in the navigation graph ComposeNavGraph(0x0) 
startDestination={Destination(0xa268bffc) route=login}.

The Root Cause and the Solution

This error occurs because URLs contain special characters that can cause issues when passed through navigation routes. Therefore, we can’t pass the URL as-is. The solution is to encode the image URL before passing it between screens and then decode it in the receiving screen. Both encoding and decoding are simple operations that are part of the Android SDK.

Updating the App

To resolve the issue, we need to modify a few parts of the app:

LoginApp:
The navigation routes need to be updated. In the previous implementation, we were passing only the image name to the image details screen and fetching the image from local storage. Now, we will pass both the image name and the encoded image URL to the image details screen.
Image List Screen:
In this screen, we will fetch the images from URLs using Coil. We’ll encode the URLs before passing them to the image details screen.
Image Details Screen:
Here, we will decode the URL to properly display the image using Coil, as well as handle the image name and other details.

In the image list screen, I created a custom composable called "NetworkImage" and used it within the column.


@Composable
fun NetworkImage(navController: NavController, imageName: String, url: String) {
    val painter = rememberAsyncImagePainter(url)
    Image(
        painter = painter,
        contentDescription = imageName,
        modifier = Modifier
            .fillMaxWidth()
            .height(200.dp)
            .padding(bottom = 16.dp)
            .clickable {
                navController.navigate("imageDetailsScreen/$imageName/${encodeUrl(url)}")
            },
        contentScale = ContentScale.Crop
    )
}

fun encodeUrl(rawUrl: String): String {
    return URLEncoder.encode(rawUrl, StandardCharsets.UTF_8.toString())
}

fun decodeUrl(encodedUrl: String): String {
    return URLDecoder.decode(encodedUrl, StandardCharsets.UTF_8.toString())
}

Here are few updated screen shots

1. Image list Screen

2. Image Details Screen

Here is the complete source code

Building My First Android Jetpack Compose Application: A Simple Multi-Screen App - Part - 1

noreply@blogger.com (androidians) — Sat, 28 Sep 2024 15:00:00 +0530

In this post, I’ll walk you through the creation of my first application using Jetpack Compose. This project was a great introduction to Compose, which simplifies UI development with a declarative approach. The app itself is fairly simple and contains a few key screens, demonstrating navigation, state handling, and passing data between screens.

Overview of the Application

The app consists of four screens:

Login Screen
The journey starts with a basic login screen. Users enter their username and password here. Once they click on the Submit button, the app navigates to the next screen, passing the username forward. At this stage, no backend validation is implemented as it’s a simple introductory app.
Welcome Screen
After a successful login, the user is greeted on the welcome screen. This screen displays a message that includes the username entered on the login screen, adding a personalized touch. Besides the welcome message, there's a button labeled "Images". Clicking this button takes the user to the image list screen.
Image List Screen
The image list screen showcases a collection of images stored in the app’s drawable folder. These images are displayed in a scrollable list, and each image is clickable. When a user selects an image, they are taken to the image details screen, where more information about the image is shown. In future updates, I plan to source images from URLs and fetch them dynamically. For now, keeping them local keeps things simple and manageable.
Image Details Screen
On the image details screen, users can view the selected image in full along with its description. The screen includes a top app bar with a back arrow, making it easy for users to navigate back to the image list. The top bar also displays the image’s title for context.
Navigation between screens is smooth, and the back arrow ensures intuitive flow, allowing users to easily explore the list without getting lost.

Data Handling
All the data in this app, such as the username and image details, are stored locally within the app. This helps keep the app self-contained and fast without needing external dependencies. I’ve focused on keeping the data flow simple while demonstrating how state and UI interact in Jetpack Compose.
What’s Next?
This is just the beginning of what can be done with Jetpack Compose. In my next post, I’ll be enhancing this app by fetching images from URLs and adding more complex data handling scenarios. The goal is to continue exploring how Jetpack Compose makes Android development more streamlined, efficient, and modern.
Note: An important point to mention is that we are not using Intents for navigation in this app. Additionally, data is passed between screens without the use of Intents or Bundles. The entire app operates within a single activity.

Screenshots
1) Login Screen
Login Screen

2) Welcome Screen

3) Image List Screen

4) Image Details Screen

Full source code is available here

Discover the New Android Feature: Application Binary Interface (ABI)

noreply@blogger.com (androidians) — Wed, 29 May 2024 08:45:00 +0530

A Quick History Lesson

In the Android world, there are two main types of devices: those with 32-bit architecture and those with 64-bit architecture. Some devices can handle both, but the trend is moving towards a 64-bit only future. Take the Pixel 7, for example—it's a 64-bit only device. So why is this shift happening?

Here are a few key reasons:

Speed: 64-bit apps run faster. They can access extra registers and instructions that 32-bit apps can't.

Security: The larger address space of 64-bit systems enhances security measures like Address Space Layout Randomization (ASLR). Plus, the extra bits can help protect the integrity of control flow. Memory

Efficiency: Dropping 32-bit support can save up to 150 MB of RAM, which the OS previously needed even when 32-bit apps weren't running.

What Are ABIs?

Different Android devices have different CPUs, and each CPU supports specific instruction sets. Every combination of a CPU and its instruction set has its own Application Binary Interface (ABI).

Want to check if your device is 64-bit? Look at the value of android.os.BUILD_SUPPORTED_ABIS. This will tell you if your device supports 64-bit architecture. Testing your apps on 64-bit devices is essential because that's where Android is headed, offering more power and efficiency.

Happy coding!

Simple way to show a list using compose - Call Log Details

noreply@blogger.com (androidians) — Mon, 29 Apr 2024 10:54:00 +0530

Without much ado, here is a simple way to show call log details.

I am breaking the functionality to few sub tasks as,

a) First get the permission to fetch call log from user

b) Then fetch the call log details from Implicit callLog content provider &

c) Finally show the list using Jetpack Compose.

Going to show the code snippet as well in 3 different sections same as subtask.

Fetching Permission from user. Here I am showing the comprehensive way to ask permission. Literally we can ask permission from user 2 times from app. If user denies the permission in all cases, then show the app info page from settings. I will show the complete code snippet here using RequestLauncher


override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Check if the permission is already granted
        checkCallLogPermission()
}

private fun checkCallLogPermission() {
	if (ContextCompat.checkSelfPermission(
    	this,
        Manifest.permission.READ_CALL_LOG
	) != PackageManager.PERMISSION_GRANTED
   ) {
   // Permission is not granted, request it
   callLogPermissionLauncher.launch(Manifest.permission.READ_CALL_LOG)
	} else {
		// fetch details from call log content provider
		fetchCallLog()
	}
}

private val callLogPermissionLauncher = registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted: Boolean ->
	if (isGranted) {
		fetchCallLog()
	} else {
		if (shouldShowPermissionRationale(this, Manifest.permission.READ_CALL_LOG)) {
			checkCallLogPermission()
        } else {
            // show App Info page to allow permission
            openAppSettings(this)
		}
	}
}

private fun fetchCallLog() {
	setContent {
		MaterialTheme {
			DisplayCallLog()
		}
	}
}

fun shouldShowPermissionRationale(context: Activity, permission: String): Boolean {
	return ActivityCompat.shouldShowRequestPermissionRationale(context, permission)
}

fun openAppSettings(context: Context) {
  val intent = Intent().apply {
      action = android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS
      data = Uri.fromParts("package", context.packageName, null)
  }
  context.startActivity(intent)
}

After getting permission fetch call log details from implicit content provider. Here I am fetching details for last 10 days. Code snippet for the same is as follows,



@Composable
fun DisplayCallLog() {
    val context = LocalContext.current
    var callLog by remember {
        mutableStateOf(emptyList<CallLogItem>())
    }
    // Check permission to read call logs
    val hasPermission = remember {
        ContextCompat.checkSelfPermission(
            context,
            Manifest.permission.READ_CALL_LOG
        ) == PackageManager.PERMISSION_GRANTED
    }

    if (hasPermission) {
        // Fetch call logs
        callLog = CallLogUtils.fetchCallLogData(contentResolver = context.contentResolver, daysToBeFetched = -10)
    }

    CallLogList(callLog)
}


fun fetchCallLogData(contentResolver: ContentResolver, daysToBeFetched: Int) : ArrayList<CallLogItem> {
	val callLogList = ArrayList<CallLogItem>()
	val projection = arrayOf(
		CallLog.Calls._ID,
        CallLog.Calls.NUMBER,
        CallLog.Calls.TYPE,
        CallLog.Calls.DATE,
        CallLog.Calls.DURATION
	)

	// Calculate the date - daysToBeFetched days ago
	val tenDaysAgo = DateUtils.addDays(daysToBeFetched)

	// Define the selection criteria
	val selection = "${CallLog.Calls.DATE} > ?"

	// Define the selection arguments
	val selectionArgs = arrayOf(tenDaysAgo.toString())

	// Perform the query
	val cursor: Cursor? = contentResolver.query(
		CallLog.Calls.CONTENT_URI,  // The content URI of the call log provider
        projection,                 // The columns to retrieve
        selection,                  // Selection criteria (for last 10 days data)
        selectionArgs,              // Selection arguments (date 10 days ago)
        "${CallLog.Calls.DATE} DESC" // Sort order (by date in descending order)
	)

	// Process the cursor
	cursor?.use { cursorToProcess ->
		val idColumnIndex = cursorToProcess.getColumnIndex(CallLog.Calls._ID)
		val numberColumnIndex = cursorToProcess.getColumnIndex(CallLog.Calls.NUMBER)
		val typeColumnIndex = cursorToProcess.getColumnIndex(CallLog.Calls.TYPE)
		val dateColumnIndex = cursorToProcess.getColumnIndex(CallLog.Calls.DATE)
		val durationColumnIndex = cursorToProcess.getColumnIndex(CallLog.Calls.DURATION)

		while (cursorToProcess.moveToNext()) {
			val id = cursorToProcess.getLong(idColumnIndex)
			val number = cursorToProcess.getString(numberColumnIndex)
			val type = cursorToProcess.getInt(typeColumnIndex)
			val date = cursorToProcess.getLong(dateColumnIndex)
			val duration = cursorToProcess.getLong(durationColumnIndex)

			val callType: String = when (type) {
				CallLog.Calls.INCOMING_TYPE -> "Incoming"
				CallLog.Calls.OUTGOING_TYPE -> "Outgoing"
				CallLog.Calls.MISSED_TYPE -> "Missed"
				else -> "Unknown"
			}

			// Process the call log data
			Log.d("CallLogData", "ID: $id, Number: $number, Type: $type, " +
				"Date: $date, Duration: $duration, callType: $callType")

			callLogList.add(CallLogItem(
				number,
				type,
				date,
				duration
			))
		}
	}


	// Close the cursor explicitly
	cursor?.close()
	return callLogList
}
    
fun addDays(days: Int) : Long {
	val calendar = Calendar.getInstance()
	calendar.add(Calendar.DAY_OF_YEAR, days)
	return calendar.timeInMillis
}

Finally the code snippet to show the list of callLog items using compose functions is as follows,



@Composable
fun CallLogItem(callLogItem: CallLogItem) {
    Column(
        modifier = Modifier
            .padding(16.dp)
    ) {
        Text(text = "Number: ${callLogItem.phoneNumber}", fontWeight = FontWeight.Bold)
        Text(text = "Type: ${callLogItem.callLogType}")
        Text(text = "Date: ${callLogItem.date}")
        Text(text = "Duration: ${callLogItem.duration}")
    }
}

@Composable
fun CallLogList(callLog: List<CallLogItem>) {
    LazyColumn(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp)
    ) {
        items(callLog) { callLogItem ->
            CallLogItem(callLogItem = callLogItem)
        }
    }
}

UI loks so simople and without any xml file. All code using kotlin itself. I am started enjoying using compose. I hope you guys also enjoying it.

We can improve the UI using callLogType. According to the callLog type, we can change the color like for missed call, give red, outgoing give green and so on. Use the below code snippet to find the type of call log

val callType: String = when (callLogType) {
	CallLog.Calls.INCOMING_TYPE -> "Incoming"
	CallLog.Calls.OUTGOING_TYPE -> "Outgoing"
	CallLog.Calls.MISSED_TYPE -> "Missed"
	else -> "Unknown"
}

And last but not least the dependencies used in the application are as follows,

dependencies {
    implementation 'androidx.core:core-ktx:1.8.0'
    implementation platform('org.jetbrains.kotlin:kotlin-bom:1.8.0')
    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.3.1'
    implementation 'androidx.activity:activity-compose:1.5.1'
    implementation platform('androidx.compose:compose-bom:2022.10.00')
    implementation 'androidx.compose.ui:ui'
    implementation 'androidx.compose.ui:ui-graphics'
    implementation 'androidx.compose.ui:ui-tooling-preview'
    implementation 'androidx.compose.material3:material3'
    implementation "androidx.compose.runtime:runtime-livedata"
}

Happy Exploring!!
Keep Rocking..

Receive SMS using SmsRetriever in Android Kotlin

noreply@blogger.com (androidians) — Mon, 1 Jan 2024 13:44:00 +0530

In this article, I will explain how to receive SMS using SmsRetriever.

First we have to add the dependency,

dependencies {
def playServicesVersion = 18.0.1
implementation 'com.google.android.gms:play-services-auth-api-phone:$playServicesVersion'
}

Next step is add user consent to read OTP messages is as follows

val task = SmsRetriever.getClient(context).startSmsUserConsent(senderPhoneNumber)
task.addOnSuccessListener {
// Successfully started SMS retriever
}

task.addOnFailureListener {
// Failed to start SMS retriever
}

Now create a broadcast receiver in the activity and register it using registerReceiver()

private val smsReceiver = object : BroadcastReceiver() {
  override fun onReceive(context: Context, intent: Intent) {
  	if (SmsRetriever.SMS_RETRIEVED_ACTION == intent.action) {
    	val extras = intent.extras
        extras?.let {
          val status = it.get(SmsRetriever.EXTRA_STATUS) as Status
          when (status.statusCode) {
          	CommonStatusCodes.SUCCESS -> {
            val consentIntent = extras.getParcelable<Intent>(SmsRetriever.EXTRA_CONSENT_INTENT)
            try {
            	startActivityForResult(consentIntent, SMS_CONSENT_REQUEST)
            } catch (e: ActivityNotFoundException) {
            	Log.e("smsReceiver", "failed to show the SMS user consent dialog", e)
            }
            }
            CommonStatusCodes.TIMEOUT -> {
            	// take appropriate action here
            }
            else -> {}
         }
       }
    }
  }
}

Now register the receiver in activity onResume() using

val filter = IntentFilter(SmsRetriever.SMS_RETRIEVED_ACTION)
registerReceiver(smsReceiver, filter)

unregister the receiver in onPause() as well to avoid any leakage.

Now get the user consent response in onActivityResult()



override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
	super.onActivityResult(requestCode, resultCode, data)
    when (requestCode) {
    	SMS_CONSENT_REQUEST ->
	        if (resultCode == RESULT_OK) {
            	data?.let {
                	val message = it.getStringExtra(SmsRetriever.EXTRA_SMS_MESSAGE)
                    if (message != null ) {
                    	getOtp(message)
                    }
                }
            } else {
             // take appropriate action here as user didn't give permission to read OTP messages
            }
        
    }
}

private fun getOtp(msg: String) {
    // here the problem is all digits in the same will show here. Which cause issues so better to get the OTP using regex
    //val otp = message.filter { it.isDigit() } 
    // here OTP has 6 digits, so I am taking 6 digits which are coming together only
    val pattern = "\\b\\d{6}\\b".toRegex()
    val matchResult = pattern.find(msg)
    if (matchResult != null) {
    	// val otp has the otp value that we got from SMS 
    	val otp = matchResult.value
    }
}

So, that's guys. Important thing to note here is no extra permission we require as READ_SMS and so on and all in all, it's a shorter and easier approach to read OTP messages. Hope you enjoyed the article

Happy exploring!!

How to check DND (Do Not Disturb) is turned on in Android

noreply@blogger.com (androidians) — Tue, 19 Dec 2023 16:00:00 +0530

Little hacks from my daily professional life sharing here. Utility function to check whether DND is turned on or not is as follows,

fun isDndEnabled(context: Context): Boolean {
	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    	val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
        return notificationManager.currentInterruptionFilter == NotificationManager.INTERRUPTION_FILTER_NONE
    } else {
        // For devices below Android M
        val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
        return audioManager.ringerMode == AudioManager.RINGER_MODE_SILENT
    }
}

Here, for Android version M (API level 23) and above, we are using notificationManager to check DND is enabled or not. It uses `currentInterruptionFilter `property of notificationManager to check DND is enabled. If `currentInterruptionFilter ` equals `NotificationManager.INTERRUPTION_FILTER_NONE` it means "Do Not Disturb" mode is on.

For Android version below M (API level 22 and below), we are using AuidoManager's ringerMode to check "Do Not Disturb" is enabled. If ringerMode equals `AudioManager.RINGER_MODE_SILENT` that means DND is enabled.

Happy Exploring!!!

Communication between 2 different Android apps using Broadcast Receiver in Android 13 and above

noreply@blogger.com (androidians) — Sat, 16 Dec 2023 20:20:00 +0530

Communication between 2 android apps can happen through various ways. If we want to share data in a structured way, then content provider is the way to go. If we want to launch an activity of another app, we can use intents with the package name of the other app. One thing to note here is the in manifest the activity should add android:exported = true.

Here I am going to explain communication between 2 android apps using Broadcast Receiver. I will explain this in a step by step manner.

1. Firstly, I create 2 android apps one Sender and another Receiver.

2. From Sender app, I create an intent with an action. Then send a broadcast.

3. This broadcast message will be received in receiver app through broadcast receiver. In receiver app, we have to declare the receiver with intent-filter. Where the action has to be defined. The action should be same as the once set in Sender app. One thing to note here is, in manifest file, mark the receiver with android:exported=true

Note: The action defined should be unique otherwise conflict can occur and which leads to race condition. So it is better to create the action with the package name as prefix. and then provide a verb which defines the action, in this case, it is send.

eg: com.androidians.receiver.ACTION_SEND_DATA_FROM_ANDROIDIANS

Code snippets

1. Code snippet to send the broadcast message is as follows,

val intent = Intent("com.androidians.receiver.ACTION_SEND_DATA_FROM_ANDROIDIANS")
intent.putExtra("data", "Hello from Sender")
sendBroadcast(intent)

2. Code snippet to declare the receiver in manifest is as follows,

<receiver android:exported="true" android:name=".DataReceiver">
<intent-filter>
<action android:name="com.androidians.receiver.ACTION_SEND_DATA_FROM_ANDROIDIANS">
</action></intent-filter>
</receiver>

3. Code Snippet for the Broadcast receiver is as follows,

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.util.Log
import android.widget.Toast

class DataReceiver : BroadcastReceiver() {

    override fun onReceive(context: Context?, intent: Intent?) {
        Log.e("DataReceiver", intent?.getStringExtra("data")?: "")
        val msg = intent?.getStringExtra("data")?: ""
        Toast.makeText(context, "Message from sender, $msg", Toast.LENGTH_SHORT).show()
    }

}

4. Registering receiver in Android 13 and above is little different. Code snippet to register and unregister receiver is as follows,

private val dataReceiver = DataReceiver()
override fun onCreate(savedInstanceState: Bundle?) {
...
val intentFilter = IntentFilter("com.androidians.receiver.ACTION_SEND_DATA_FROM_ANDROIDIANS")
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
  registerReceiver(dataReceiver, intentFilter, RECEIVER_EXPORTED)
} else {
  registerReceiver(dataReceiver, intentFilter)
}
}

override fun onDestroy() {
  super.onDestroy()
  unregisterReceiver(dataReceiver)
}

If we need to provide more security, we can add permission. That is one way to secure the data passed between the apps.

That's it.

Happy Exploring!!

Android Jetpack Compose simple examples

noreply@blogger.com (androidians) — Tue, 17 May 2022 14:20:00 +0530

I just started with Jetpack compose. When I tried my first sample app, I got an error, so thought of share with you all. When I run the below code snippet


import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.activity.compose.setContent
import androidx.compose.material.Text

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Text("Hello world!!")

        }
    }
}

My app crashed with the below error,



java.lang.NoSuchMethodError: No static method setContent$default(Landroidx/activity/ComponentActivity;
Landroidx/compose/runtime/CompositionContext;Lkotlin/jvm/functions/Function0;ILjava/lang/Object;)V in 
class Landroidx/activity/compose/ComponentActivityKt; or its super classes (declaration of 
'androidx.activity.compose.ComponentActivityKt' appears in /data/app/

The issue was in gradle file need to add buildFeatures,


buildFeatures {
   compose true
}

Another change required in gradle file is,


composeOptions {
    kotlinCompilerExtensionVersion = "1.2.0-alpha08"
}

These are the 2 changes you have to made while building apps using Jetpack Compose, the modern toolkit for building native UI.

The screen shot for the same is,

Screen shot of Hello world app using Jetpack Compose

One last thing before winding up is the dependencies I used are,


// compose
implementation 'androidx.activity:activity-compose:1.4.0'
// compose material design
implementation 'androidx.compose.material:material:1.1.1'

That's it.

Happy exploring!!

Create Password protected zip file in mac terminal

noreply@blogger.com (androidians) — Thu, 12 May 2022 21:24:00 +0530

To create password protected zip file in Mac use this command,


zip -e destination-file.zip source-file.extension
eg:
zip -e password.zip password.txt

After entering the command, terminal prompts to enter the password, enter the password and verifies it. That's it.

Happy exploring!!

Error: Remote repository not found

noreply@blogger.com (androidians) — Wed, 11 May 2022 08:52:00 +0530

I am trying to clone a github repo from mac terminal and got the error as "remote repository not found". Later I found, we have to pass the userName while clone the github repo. There is a slight modification in the command. The modified command is as follows,

   
 eg. git clone https://user@github.com/fooo/foo.git

Happy Exploring!!

Not able to build android project with butterknife library

noreply@blogger.com (androidians) — Tue, 10 May 2022 05:56:00 +0530

As my current project still has dependency to butterknife in gradle file. I am not using it but need to keep it as part of the legacy code we have in the project and I got a strange error like

  
cause: superclass access check failed: class butterknife.compiler.butterknifeprocessor$rscanner 
(in unnamed module) cannot access class com.sun.tools.javac.tree.treescanner (in module jdk.compiler) 
because module jdk.compiler does not export com.sun.tools.javac.tree to unnamed module

It bugged my head and later I found the solution, it is in gradle use the JDK version 11 instead of 16. I was using JDK16, which causes the error. When I modified to JDK 11, it all started working fine.

Happy exploring!!

Publish Android Library Artifacts to Amazon S3 bucket

noreply@blogger.com (androidians) — Sun, 17 Apr 2022 12:15:00 +0530

Even though we can use Jetpack for hosting public and private repositories, I am not happy with it especially when publishing private repositories.

The solution that I come across is to use MavenLocal task from the maven publish plugin and then publish the Android library artifacts to Amazon S3 bucket.

The step by step procedure to publish Android library artifacts to Amazon S3 buckets using maven plblish plugin is as follows,

1. Firstly create a IAM user in Amazon aws. So that if anything goes wrong there is limited exposure.

2. Now create secretKey and secretAccessKey for the user, basically user credentials need to be generated. This AwsCredentials we have to use in the gradle file of android library. So keep it handy for future usage.

3. Then setup the amazon s3 bucket, where we will place the android library artifacts like, aar, pom file, sha1, md5 and so on. So that is it. Amazon aws part is done. Now move to our android library gradle file.

4. Here, initllay maven publish plugin has to be added. Sample code snippet is,


apply plugin: 'com.android.library'
apply plugin: 'maven-publish'

5. Now add the group name and version as follows,


group = 'com.companyname.library-name'
version='1.0.0'

6. Now, add sources as an artifact as follows,


task sourceJar(type: Jar) {
  from android.sourceSets.main.java.srcDirs
  classifier "sources"
}

7. After this, loop over all variants,


android.libraryVariants.all { variant ->
  variant.output.all { output ->
    publishing.publications.create(variant.name, MavenPublication) {
       artifact sourceJar
       artifact source:output.outputFile, classifier: output.fileName
    }
  }
  pom.withXml {
   .............
  }
}

8. Ensure that publish task depends on assembly.



tasks.all {
  if (task instanceOf AbstractpublishToMaven) {
     task.dependsOn assemble
  }
}

9. Configure the destination repository with S3 URL and add aws IAM user credentials


publishing {
   repositories {
   	  maven {
         url BUCKET-NAME.s3.amazonaws.com
         credentials (AwsCredentials) {
            accessKey ....
            secretKey ....
         }
      }
   }
}

10. Finally, run th epublish task in the terminal as,



./gradlew libraryName:publish

11. Not over yet, the last point is, to use the library in other project, add the below code snippet in root gradle file


allProjects {
  repositories {
     google()
     Jcenter()
     maven {
       url BUCKET-NAME.s3.amazonaws.com"
      credentials (AwsCredentials) {
         accessKey "..."
        secretkey "....."
      }
     }
}

So, that is it guys.

Keep Exploring!!!

Tracks the screen view events in Android

noreply@blogger.com (androidians) — Sun, 10 Apr 2022 15:50:00 +0530

As you all know screen in Android can be either an activity or a fragment. So say, you want to track the screen view events from SDK you created, you can do so using, registerActivityLifecycleCallbacks()`&

registerFragmentLifecycleCallbacks()

These two methods come handy to register the screen view events for analytics purpose. Similar like how firebase track the screen view events.

Here, things to note is registerActivityLfecycleCallbacks() has to be called from the application class and registerFragmentLifecycleCallbacks() has to be called from say the baseActivity(if you have one in your project) or else in the activities that you wish to track.

The code snippet for the same is as follows,

To register the callback for activity, add it in application base class as,

class BaseApplication : Application() {

    override fun onCreate() {
        super.onCreate()
        registerActivityLifecycleCallbacks(ViewLifecycleCallbacks())
    }

}

To register for fragment callbacks, add in base activity or in which ever activity you are interested in,

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

class BaseActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        supportFragmentManager.registerFragmentLifecycleCallbacks(ViewLifecycleCallbacks(), true)
    }
}

Now, finally our ViewLifecycleCallbacks class is as follows,

class ViewLifecycleCallbacks : Application.ActivityLifecycleCallbacks, FragmentManager.FragmentLifecycleCallbacks() {

    // activity callbacks
    override fun onActivityCreated(p0: Activity, p1: Bundle?) {
        TODO("Not yet implemented")
    }
    ......
    // fragments callbacks
    override fun onFragmentPreAttached(fm: FragmentManager, f: Fragment, context: Context) {
        super.onFragmentPreAttached(fm, f, context)
    }
    ......

Happy Exploring!!!

Creating hash in Android

noreply@blogger.com (androidians) — Sat, 9 Apr 2022 14:03:00 +0530

There are various algorithms to create hash value. Some of them are MD5, SHA1, SHA256 and more. The best way to create hash value is using SHA256 beacuse it create a long output so that collision will be minimal.

The code snippet for the hashing valuse using SHA-256 is as,

private fun createHash(s: String) : String {
        val messageDigest = MessageDigest.getInstance("SHA-256")
        messageDigest.update(s.toByteArray(Charsets.UTF_8))
        return String(messageDigest.digest())
}

So that is all for today.

Happy exploring!!

Issue with Room and Mac OS

noreply@blogger.com (androidians) — Fri, 28 Jan 2022 05:59:00 +0530

This is a long disturbing problem for me. Whenever I am using a simple android project with room, build is failing. I was literally fed up with the issue. Finally what I did is, I wake up early morning and try to find the exact solution and it seems with the Mac OS, not with the code. First the error is as follows,


FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':app:kaptDebugKotlin'.
> A failure occurred while executing org.jetbrains.kotlin.gradle.internal.KaptWithoutKotlincTask$KaptExecutionWorkAction
   > java.lang.reflect.InvocationTargetException (no error message)

The solution for this is we have to use the embedded JDK that comes along with the Android Studio. I am attaching screen shot for reference.

Happy exploring!!

Wallpaper in Android

noreply@blogger.com (androidians) — Wed, 19 Jan 2022 17:17:00 +0530

Setting wallpaper in android is pretty simple, just two lines of code. First get the instance of wallpaper manager and using the API setResource() is one of the way to set wallpaper from resources and I think, it is the simplest. The code snippet is,


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

  val wallpaperMgr = WallpaperManager.getInstance(applicationContext)
  findViewById<Button>(R.id.setWallpaperBtn).setOnClickListener {
     wallpaperMgr.setResource(R.drawable.img)
  }
}

You can also use other methods like setBitmap(), to set wallpaper

Happy Exploring!!

Resize Bitmap in Android without losing much quality

noreply@blogger.com (androidians) — Thu, 23 Dec 2021 12:12:00 +0530

Without losing much of quality to scale bitmap, its better to use "matrix" rather than createScaledBitmap()


private static Bitmap getResizedBitmap(Bitmap bitmap, int newWidth, int newHeight, boolean keepOriginal) {
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();
        float scaleWidth = ((float) newWidth) / width;
        float scaleHeight = ((float) newHeight) / height;
        
        Matrix matrix = new Matrix();        
        matrix.postScale(scaleWidth, scaleHeight);
        Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, false);
        if(!keepOriginal){
            bitmap.recycle();
        }
        return resizedBitmap;
}

Resizing bitmap using "createScaledBitmap()"


public static Bitmap getResizedBitmap(Bitmap image, int maxSize) {
	int width = image.getWidth();
	int height = image.getHeight();
	float bitmapRatio = (float) width / (float) height;
	if (bitmapRatio > 1) {
		width = maxSize;
		height = (int) (width / bitmapRatio);
	} else {
		height = maxSize;
		width = (int) (height * bitmapRatio);
	}
	return Bitmap.createScaledBitmap(image, width, height, true);
}

While using createScaledBitmap(), put the last param as true because it will do the bilinear filtering for resampling to prevent aliasing.

Happy exploring!!

To prevent screen capture in Android

noreply@blogger.com (androidians) — Tue, 7 Dec 2021 17:01:00 +0530

To prevent screen capture in Android is pretty easy. It is just one line code. The code snippet in kotlin is

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    window.setFlags(WindowManager.LayoutParams.FLAG_SECURE, WindowManager.LayoutParams.FLAG_SECURE)
}

The code snippet in java is as follows,

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_SECURE, WindowManager.LayoutParams.FLAG_SECURE);
}

When you try to take a screen shot you will get a notification like this,

Notification appears when you try to take a screen shot

Happy exploring!!

MaterialCardView in Android

noreply@blogger.com (androidians) — Sat, 20 Nov 2021 18:14:00 +0530

If materialCardView is the root element, then clickable and focusable to true is not necessary, but when it materialCardView is a child element then for making the ripple effect when clicking on the card we have to explicitly mention clickable and focusable to true for the ripple effect when clicked on the card.

The code snippet is,

<com.google.android.material.card.MaterialCardView

android:background="?android:attr/selectableItemBackground"

android:clickable="true"

android:focusable="true"

……

Happy exploring!!!

Coroutines Basics and Structured Concurrency in Coroutines

noreply@blogger.com (androidians) — Sun, 26 Sep 2021 12:48:00 +0530

What is coroutines?

A coroutine is an instance of suspendable computation. Conceptually it is similar to a thread, in the sense that it takes a block of code to run that works concurrently with the rest of the code.

However, a coroutine is not bound to any particular thread. It may suspend its execution in one thread and resume in another one.

Coroutine builders

launch() - is a coroutine builder. It launches a new coroutine concurrently with the rest of the code, which continues to work independently.

delay() - is a special coroutine function. It suspends the coroutine for a specific time. Suspending a coroutine does not delay the underlying thread it created.

runBlocking() - is also a coroutine builder that bridges the non coroutine world with coroutine world - RunBlocking means that the thread that it runs will get blocked for the duration of the call, means until all coroutines inside runBlocking {} complete their execution.

async() is another coroutine builder, that we will see later.

Structured Concurrency

Coroutines follows a principle called structured concurrency, which means a new coroutine can only be launched in a coroutineScope, which determines the lifetime of the coroutine.
An outer scope cannot complete until all its children coroutines complete
Structured concurrency also ensures that any error are properly reported and never lost.

eg:)


fun main() = runBlocking { // this: CoroutineScope
    launch { // launch a new coroutine and continue
        delay(1000L) // non-blocking delay for 1 second (default time unit is ms)
        println("World!") // print after delay
    }
    println("Hello") // main coroutine continues while a previous one is delayed
}

Parallel decomposition

Sample code that shows how to load two images in parallel and combine them later


suspend fun loadAndCombine(name1: String, name2: String): Image { 
    val deferred1 = async { loadImage(name1) }
    val deferred2 = async { loadImage(name2) }
    return combineImages(deferred1.await(), deferred2.await())
}

Unfortunately, this example is wrong on many levels
The suspending function loadAndCombine, itself, is going to be called from inside a coroutine. What if that operation gets cancelled? Then loading of both images still proceeds unfazed. That is not what we want from a reliable code
With structured concurrency async coroutine builder became an extension on CoroutineScope just like launch did. You cannot simply write async { … } anymore, you have to provide a scope.

A proper example of parallel decomposition becomes:


suspend fun loadAndCombine(name1: String, name2: String): Image =
    coroutineScope { 
        val deferred1 = async { loadImage(name1) }
        val deferred2 = async { loadImage(name2) }
        combineImages(deferred1.await(), deferred2.await())
 }

You have to wrap your code into coroutineScope { … } block that establishes a boundary of your operation, its scope.
All the async coroutines become the children of this scope and, if the scope fails with an exception or is cancelled, all the children are cancelled, too.

Coroutines vs Threads

Threads are heavy or expensive. We are told that threads are expensive resources and one should not go around creating them left and right. A well written program usually creates a thread pool at startup and then uses it to offload various computations.

But the story is different with coroutines. it is very convenient to create coroutines since they are so cheap.

Coroutines are always related to some local scope in our application, which is an entity with a limited life-time, like a UI element. We rarely launch coroutines "globally" like we do with threads. When launching coroutines globally, we have to explicitly declare the global scope as, GlobalScope.launch()

Happy exploring!!!

How to investigate ANR (Application Not Responding) in Android

noreply@blogger.com (androidians) — Fri, 24 Sep 2021 13:11:00 +0530

You may already know ANR occurs when we do long running operation on our main or UI thread. For example, on click of the button do a operation like download an image over the network, say it took more than 5 seconds. Then you may feel like UI gets freeze and application not responding. Basically any task which took more than 5 seconds on the main thread cause ANR.

Unlike crashes, finding the exact cause of ANR is difficult, as logical may not have the line number and file name to say, where exactly app is having the issue.

What need to do is,

1. First get the /data/anr/traces.txt from the device which happened using the add command


  adb shell "cd /data/anr && cat traces.txt" > anr.txt

Now, we copy the traces.txt to anr.txt. search for "waiting to lock", there could be potential issue around these lines. You will get the fileName and lineNumber in these area.

Another way to get the traces.txt is by


  add pull /data/anr/traces.txt

it will download the files to the current directory.

Another methods to find ANRs are like using popular libraries like leakCanary.

Happy exploring!!!

WorkManager in Android

noreply@blogger.com (androidians) — Tue, 7 Sep 2021 16:56:00 +0530

WorkManager came to android as part of JetPack library. We can use it for long running background tasks. By default all the code inside the doWork() will run in a separate thread.

There are two types of Workers are there.

1) oneTimeWorker &

2) periodicWorker.

One TimeWorker from the name itself, we can understand that, it will run once only. We can specify the time, add constraints etc.

Periodic worker, similar like alarm managers but work manager respect doze mode.

Happy coding!!

Github Personal Access Token (PAT)

noreply@blogger.com (androidians) — Thu, 2 Sep 2021 17:07:00 +0530

Github removed the support for password authentication and now we have to use the personal access token for authentication. We can set the expiration time for the token as 30 days, 60 days, 90 days etc. Once PAT is generated we have to save it securely.

The steps are,

1. In the right hand side click on the profile icon.

2. From the drop down select "settings"

3. In settings page select developer settings from the left pane.

4. Now in developer settings page, click on "generate token" and check relevant permissions required

Happy Exploring !!

Androidians

How to Set Up Multiple GitHub Accounts in Android Studio Using SSH

Step 1: Check Existing SSH Keys

Step 2: Generate SSH Key for First GitHub Account

Files Generated

Step 3: Generate SSH Key for Second GitHub Account

Step 4: Add Both Keys to SSH Agent

Start SSH Agent

Add Both Keys

Verify Loaded Keys

Step 5: Configure SSH

Step 6: Add Public Keys to GitHub

First Account

Second Account

Step 7: Test SSH Connections

First Account

Second Account

Step 8: Clone Repositories Using Host Alias

Clone Repository for First Account

Clone Repository for Second Account

Important

Step 9: Configure Git Identity Per Repository

First Repository

Second Repository

Verify Configuration

Step 10: Update Existing Repositories

Check Current Remote

Update Remote URL

First Account

Second Account

Verify Updated Remote

Common Error

Final Notes

WorkManager Policies Demystified: KEEP vs CANCEL_AND_REENQUEUE vs UPDATE (With Real Example)

Fetching Images from URLs in Jetpack Compose: Part 2 of the Login App

Adding Coil to the Project

Switching from Local to Remote Images

The Root Cause and the Solution

Updating the App

Building My First Android Jetpack Compose Application: A Simple Multi-Screen App - Part - 1

Overview of the Application

Data Handling

What’s Next?

Discover the New Android Feature: Application Binary Interface (ABI)

Simple way to show a list using compose - Call Log Details

Receive SMS using SmsRetriever in Android Kotlin

How to check DND (Do Not Disturb) is turned on in Android

Communication between 2 different Android apps using Broadcast Receiver in Android 13 and above

Android Jetpack Compose simple examples

Create Password protected zip file in mac terminal

Error: Remote repository not found

Not able to build android project with butterknife library

Publish Android Library Artifacts to Amazon S3 bucket

Tracks the screen view events in Android

Creating hash in Android

Issue with Room and Mac OS

Wallpaper in Android

Resize Bitmap in Android without losing much quality

To prevent screen capture in Android

MaterialCardView in Android

Coroutines Basics and Structured Concurrency in Coroutines

How to investigate ANR (Application Not Responding) in Android

WorkManager in Android

Github Personal Access Token (PAT)