Android Development MOC

• Open Source: the Android OS is fully open-source, meaning that you can develop for a platform that you can fully understand.
• Lower barrier to entry: While not as accessible as Web Development, Android Development is accessible to anyone interested in the topic, you only need a computer with Any of the major OS (Windows, Linux, Mac)
• Cross-platform opportunities: Skills in Android development translate well into other Mobile and Backend platforms.
• Best practices and Resources: The Android community is known for having good Architecture practices that in another platform they aren’t really taking into account, this might add complexity at the beginning, but as time goes this can help you build better software in any other platform.

1. Fragmentation: Android is the most used OS, which means that it runs on **many **devices, which causes difficulty in making sure that your app works across all devices and form factors.
2. Permission Management: Properly handling permissions across multiple versions of Android can be a complex task as permission changes across multiple versions of Android.
3. Customisation: Android has the particular characteristic of being able to customise quite a lot of the OS, which is a good thing for users, but as developer that means that you need to test your app with different screen resolutions, font sizes, accessible talk back, high contrast, dark mode and even in desktop mode.
4. Backwards Compatibility: Although this can be implicit in the first point, it is important that besides testing across devices and customisation options you test older versions of Android as well.
5. Play Store Restrictions & Guidelines: Google’s Play Store constantly changes their rules and guidelines for app submission which you need to comply otherwise you might not be able to submit your app.

• Object-Oriented Programming
• Reactive Programming

• Amper

As we’ve seen, any Activity can be an entry point for your app, but, there are other ways to start a flow in your app.

• Launcher Icon
• Android Shortcuts
• Android Widgets
• Android Voice Assistants
• Android Deeplinks
• Android Notifications

Android Splash Screen
Android Icon - Adaptive Icon

• TextView
• EditText
• Buttons
• ImageView
• ListView
• Tabs
• Dialogs
• Toast
• Bottom Sheet
• Drawer
• TopAppBar → AppBar
• BottomAppBar → ToolBar
• Animations

• Android XML / Views (Android Views)
• Jetpack Compose

Separation of Concerns

Architecture Patterns for Mobi…
Modeling ViewModel State in An…

• Serializable (Java)
  • Reflection (worst performance)
  • Easier to implement
  • Multiplatform
  • General-purpose serialization mechanism

• Serializable (KotlinX Serialization)

• Parcelable
  • Better performance (Good for performance-critical scenarios)
  • Android-specific (Stores in bundle)

• Cancellation
• Lifecycle
• Catching errors

• Conditional breakpoints

• Network inspector
• Database Inspector

• No store secrets on the client

• Android Keystore
• AES

androidx.biometric:biometric:1.1.0

val biometricManager = BiometricManager.from(context)
when (biometricManager.canAuthenticate(BIOMETRIC_STRONG or DEVICE_CREDENTIAL)) {
    BiometricManager.BIOMETRIC_SUCCESS -> // Can authenticate
    BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE -> // No biometric hardware
    BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> // Hardware unavailable
    BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED -> // No biometrics enrolled
}

val promptInfo = BiometricPrompt.PromptInfo.Builder()
    .setTitle("Biometric login for MyApp")
    .setSubtitle("Log in using your biometric credential")
    .setAllowedAuthenticators(BIOMETRIC_STRONG or DEVICE_CREDENTIAL)
    .build()

val biometricPrompt = BiometricPrompt(this, executor, object : BiometricPrompt.AuthenticationCallback() {
    override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
        // Proceed with authenticated action
    }
    override fun onAuthenticationFailed() {
        // Handle failed authentication
    }
    override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
        // Handle error
    }
})

biometricPrompt.authenticate(promptInfo)

We can create a custom permission that other apps have to comply with, in order to maybe access to IPC connections.

• Define permission <permission android:name="…">
  • Protection levels
    • normal = Don’t require user confirmation. (i.e. Internet)
    • dangerous = Require user’s permissions (i.e. Audio record) - show permission dialog requesting permission.
    • signature Restrict permission to apps that are signed with the same keystore in order to access it.
• Use permission <uses-permission android:name=".." >

Key take aways:

1. Secrets don’t belong to the app bundle
   1. Move to the backend and implement rules
   2. Restrict keys usage i.e. using app signature
2. Change app’s source code (i.e. remove ads, free premium features)
   1. Advanced code obfuscation i.e. DexGuard

• Android Room
• SQLDelight
• Realm

// common main
expect fun createDataStore() : DataStore<Preferences>

internal const val DATA_STORE_FILE = "prefs.preferences_pb"
// android main

actual fun createDataStore(context: Context) : DataStore<Preferences> {
	return createDataStore {
		context.filesDir.resolve(DATA_STORE_FILE).absolutePath
	}
}

// ios Main
fun createDataStore(): DataStore<Preferences> { 

return createDataStore {  
 val directory = 
 NSFileManager.defaultManager.URLForDirectory ( 

	directory = NSDocumentDirectory, 
	inDomain = NSUserDomainMask, 
	appropriateForURL = null,
	create = false,
	error = null
 )
requireNotNull (directory) .path + "/SDATA_STORE_FILE_NAME" 
 }
}

• Shared Preferences
• EncryptedSharedPreferences

• Internal & External Storage
• FileSystem
• External Storage (SD Cards, etc)
• Cache Storage

Credential Manager vs Account Manager:

Account manager is now Deprecated and Credential manager is the preferred way to store user’s information.

• App Functions
• Computer Control

AICore - System service isolated with

EU Enforcements

1. Talkback
2. Contrast
3. Font size
4. Touch Area (Minimum 48x48)
5. Labels & Content description

• Firebase
• PostHog
• Amplitude

• Allow to inject everywhere
  • ViewModel
  • UI (Compose/Fragment)
• Central place
• Testing & Visualisation

• Plugins
• Dependencies
• Modules

1. Shrink Resources
2. Obfuscation
3. Optimisation

Fast execution

1. Isolated from the android SDK
2. Executed in JVM
3. Frameworks:
   1. JUnit
   2. Mockito / Mockk

• Maestro

How to setup PATH and JAVA\_PATH

• Android SDK Build tool
• Android Emulator
• Android SDK Platform-tools
• Android SDK Tools

Android Application Package (APK)
  Is a** ZIP file** containing all the app’s compiled DEX files & resources, along with a merged Manifest.
  Making it ideal for simple distribution, since it is a single file that allows your app to run on all Android devices.
  
Android App Bundles (AAB)
  Is a flexible format that can’t be directly installed on a device, and it is specifically meant to be uploaded to the Google Play Console that then, **will generate an Optimised APK **based on each user’s device, removing resources that might be needed only for different screen densities, etc.
  They also allow for on-demand app features that can be dynamically loaded on runtime.
  
  

App signing is a security mechanism imposed by the Android OS and Google Play. It allows to identify the author of the app, this is to prevent people that might have access to your Play Console account from publishing or updating an app on your behalf and spread malware.

To install an APK on a device it has to be signed, even when we run manually, under the hood, Android Studio has a debug keystore.

Every app in the Play Store has to be signed. Once you publish your app, every update has to be signed with the same key.

1. Private key: Only private key can generate a successful signature for the public key
2. Public key: baked into file
3. Certificate: Identify you as the owner (name, address, country)
4. Keystore: Stores multiple public/private keys and it is used to sign an app.
   1. File format is (.jks / .keystore)
   2. STORE THIS KEY!
   3. Needs a password (different to the private key password)

signingConfigs {
 create("release") {
   storeFile = file("../signing/release.jks")
   keyAlias="app-release"
   keyPassword="password0"
   storePassword="password0"
 }
}

buildTypes {
release {
signingConfig = signingConfigs.getByName("release")
}
}

1. Minify or shrink
2. Analytics & Crashlytics
3. Test with different devices
4. Playstore Listing Optimisation
   1. Images
   2. Icon
   3. Keywords
   4. Description

1. Upload private key

• Revenue Cat
• Playstore SDK

An android project can use** both** JAR and AAR, formats, while JVM projects will only be able to use JAR files.

JAR (Java Archive)
These files are generic JVM library formats containing only compiled Java classes.

AAR (Android Archives)
Is a file format specifically for Android development, which besides regular source code, can include Android resources, such as layouts, drawables and manifests.

plugins {
    //id("com.android.library")
    //id("org.jetbrains.kotlin.android")
    //id("org.jetbrains.kotlin.plugin.compose")
    alias(libs.plugins.maven.publish)
}

publishing {
    publications {
        register<MavenPublication>("release") {
            groupId = "com.<yourGroupId>"
            artifactId = "<module>"
            version = "<Version>"

            afterEvaluate {
                from(components["release"])
            }
        }
    }
}
android {
	    publishing {
        singleVariant("release") {
            withSourcesJar()
            withJavadocJar()
        }
    }
}

• Github Maven

• GLB File: Binary transmission file for GLTF

This method allows us to override the startDestination when performing e2e testing and perform navigation from the ViewModel

import androidx.navigation.NavOptionsBuilder
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.receiveAsFlow

interface Navigator {
    val startDestination: Destination
    val navigationActions: Flow<NavigationAction>

    suspend fun navigate(
        destination: Destination,
        navOptions: NavOptionsBuilder.() -> Unit = {}
    )

    suspend fun navigateUp()
}

sealed interface NavigationAction {

    data class Navigate(
        val destination: Destination,
        val navOptions: NavOptionsBuilder.() -> Unit = {}
    ): NavigationAction

    data object NavigateUp: NavigationAction
}

sealed interface Destination {
    @Serializable
    data object HomeGraph: Destination

    @Serializable
    data object AuthGraph: Destination

    @Serializable
    data object LoginScreen: Destination

    @Serializable
    data object HomeScreen: Destination

    @Serializable
    data class DetailScreen(val id: String): Destination
}

class DefaultNavigator(
    override val startDestination: Destination
): Navigator {
    private val _navigationActions = Channel<NavigationAction>()
    override val navigationActions = _navigationActions.receiveAsFlow()

    override suspend fun navigate(
        destination: Destination,
        navOptions: NavOptionsBuilder.() -> Unit
    ) {
        _navigationActions.send(NavigationAction.Navigate(
            destination = destination,
            navOptions = navOptions
        ))
    }

    override suspend fun navigateUp() {
        _navigationActions.send(NavigationAction.NavigateUp)
    }
}

// Usage Example
  viewModelScope.launch {
            navigator.navigate(
                destination = Destination.DetailScreen(id),
            )
  }

Make sure to use AccountManager/CredentialManager

Some SDKs, like Android Biometrics require a reference to the activity, in order to work, the problem with this abstraction is that biometrics are usually used in the Data layer and throughout the app, having to handle and passing the Activity reference from multiple places and trough different layers is a leaky abstraction.

// Provided as @ActivityScoped via Hilt
class ActivityProvider : DefaultLifecycleObserver {
    private var ref: WeakReference<FragmentActivity>? = null

    fun bind(activity: FragmentActivity) {
        ref = WeakReference(activity)
        activity.lifecycle.addObserver(this)
    }

    fun get(): FragmentActivity? = ref?.get()

    override fun onDestroy(owner: LifecycleOwner) { ref = null }
}

// Activity binds itself — no reference passed anywhere
class LoginActivity : FragmentActivity() {
    @Inject lateinit var activityProvider: ActivityProvider

    override fun onCreate(...) {
        activityProvider.bind(this) // ✅ self-registers
    }
}

Problem: Given a string with '(', ')', and '\*', check if it’s valid.

• \* can act as '(', ')', or be ignored.

Example:

Input: "(*))"
Output: true

• Push Service
• User-Device Mappping
• Kafka for Queuing
• Retry logic
• Personalization