Posts Tagged :

android

The Future of Mobile Development: Trends for 2025 1024 1024 w@gner

The Future of Mobile Development: Trends for 2025

The Future of Mobile Development: Trends for 2025

As we approach 2025, the mobile development landscape is evolving faster than ever, creating exciting opportunities for innovation and growth. Here are the top trends shaping the future of mobile applications, and why staying ahead is critical for businesses and developers alike.

1. Artificial Intelligence and Machine Learning Integration

AI and ML are no longer optional for mobile apps — they’re foundational. From advanced chatbots to personalized user recommendations, these technologies enhance user engagement and streamline operations. Developers skilled in tools like Core ML and TensorFlow Lite will lead the charge in creating smarter, more adaptive applications.

2. The Rise of Superapps

Following the success of platforms like WeChat, the “superapp” concept is gaining global traction. These apps consolidate multiple services into one platform, offering everything from messaging to e-commerce. Businesses aiming to retain user engagement are likely to explore this model, which demands a robust and scalable architecture.

3. Augmented and Virtual Reality Experiences

With AR/VR technologies becoming mainstream, thanks to innovations like Apple Vision Pro, mobile applications are embracing immersive experiences. Industries such as retail, education, and entertainment are integrating AR/VR to redefine how users interact with digital content.

4. The Power of 5G Connectivity

As 5G networks expand, the possibilities for high-performance mobile apps are virtually limitless. Real-time gaming, seamless video streaming, and enhanced IoT integrations will thrive, pushing developers to build applications that can leverage this ultra-fast connectivity.

5. Mobile Commerce (M-Commerce) Growth

The shift to mobile-first shopping continues, with mobile commerce projected to dominate global e-commerce sales. Simplified payment systems, such as Apple Pay and Google Wallet, along with innovations in AR for product visualization, will enhance the mobile shopping experience.

6. Cross-Platform Development Dominance

Frameworks like Flutter and React Native are increasingly popular for building efficient, cost-effective apps across iOS and Android. While native development still holds value for high-performance needs, cross-platform tools are becoming indispensable for startups and enterprises seeking faster time-to-market.

7. Privacy and Security in the Spotlight

With regulations like GDPR and CCPA shaping data policies worldwide, mobile apps must prioritize security and transparency. Developers must incorporate privacy by design and ensure compliance through secure APIs and encryption practices.

8. Apps for Health and Wellness

Health-focused apps, integrated with wearables and IoT devices, are transforming personal fitness and telemedicine. Expect a surge in demand for apps that promote well-being, offering personalized insights and seamless integration with smart devices.

9. Sustainability and Social Responsibility

Users are increasingly drawn to apps that align with their values. Features promoting sustainability, such as carbon footprint tracking or eco-friendly recommendations, can differentiate brands in a competitive market.

10. Hyper-Personalized User Experiences

Personalization is key to user retention. Apps leveraging ML to deliver tailored content, adaptive interfaces, and context-aware notifications will lead the way in customer satisfaction.

Final Thoughts

The mobile development industry in 2025 will be defined by its adaptability, innovation, and focus on user-centric solutions. For developers and businesses, the challenge lies in embracing these trends and staying ahead of the curve.

As someone deeply passionate about mobile development, I’m thrilled by these opportunities to push boundaries and deliver cutting-edge experiences. Let’s build a future where technology seamlessly enhances our daily lives.

What trends do you see shaping the mobile world in 2025? Let’s discuss in the comments!

Understanding Coroutines in Android Kotlin: Simplifying Asynchronous Programming 1024 1024 w@gner

Understanding Coroutines in Android Kotlin: Simplifying Asynchronous Programming

Coroutines have revolutionized asynchronous programming in Android development. Introduced in Kotlin, they provide a simpler and more efficient way to handle long-running tasks like network requests or database operations without blocking the main thread.

In this blog post, we'll dive into coroutines, explain how they work, and demonstrate their practical use in an Android app. We'll also showcase how to modernize your UI using Jetpack Compose for a fully declarative UI experience.

1. What Are Coroutines?

A coroutine is a lightweight thread that can be suspended and resumed. Unlike traditional threads, coroutines:

  • Don’t block the main thread.
  • Are managed by the Kotlin Coroutine Library for optimized performance.
  • Simplify asynchronous code, making it more readable and maintainable.

Key Features of Coroutines

  1. Suspension: Coroutines can pause their execution (suspend) and resume later without blocking the thread.
  2. Structured Concurrency: Helps manage the lifecycle of coroutines within a specific scope.
  3. Lightweight: Multiple coroutines can run on a single thread without overhead.

2. Getting Started with Coroutines in Android

To use coroutines, add the following dependencies to your build.gradle file: 

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
}

3. Key Concepts of Coroutines

Launch vs. Async

  1. launch: Used when you don’t need a result from the coroutine.
  2. async: Returns a Deferred result, allowing you to await the value.

Example: 

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Launch example
    launch {
        delay(1000L)
        println("Task 1 Complete")
    }

    // Async example
    val result = async {
        delay(2000L)
        "Task 2 Result"
    }
    println(result.await())
}

Coroutine Scope

Defines the lifecycle of coroutines, ensuring they are properly canceled when the scope is destroyed. Common scopes include:

  • GlobalScope: Not recommended for Android as it ignores the app’s lifecycle.
  • LifecycleScope: Tied to the lifecycle of a UI component (e.g., Activity, Fragment).
  • ViewModelScope: Tied to a ViewModel’s lifecycle, recommended for UI-related tasks.

4. Practical Example: Coroutines in an Android App

Scenario

Create a simple app that fetches user data from a remote API and displays it on the screen using Jetpack Compose for the UI.

1. Setting Up the API

For this example, we’ll simulate an API call using a suspend function: 

suspend fun fetchUserData(): String {
    delay(2000L) // Simulate network delay
    return "User: John Doe"
}

2. ViewModel with Coroutines

Use ViewModelScope to manage the coroutine lifecycle: 

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

class UserViewModel : ViewModel() {
    val userData = MutableLiveData<String>()
    val loading = MutableLiveData<Boolean>()

    fun loadUserData() {
        loading.value = true
        viewModelScope.launch {
            try {
                val data = fetchUserData()
                userData.value = data
            } catch (e: Exception) {
                userData.value = "Error fetching data"
            } finally {
                loading.value = false
            }
        }
    }
}

3. UI with Jetpack Compose

With Compose, we eliminate XML layouts, building the UI directly in Kotlin.

Main UI

import androidx.compose.foundation.layout.*
import androidx.compose.foundation.text.BasicText
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

@Composable
fun MainScreen(userViewModel: UserViewModel = viewModel()) {
    // Observing ViewModel LiveData using Compose
    val userData by userViewModel.userData.observeAsState("User Data")
    val isLoading by userViewModel.loading.observeAsState(false)

    // Main UI Layout
    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        BasicText(
            text = userData,
            modifier = Modifier.padding(bottom = 16.dp),
            style = MaterialTheme.typography.bodyLarge
        )

        if (isLoading) {
            CircularProgressIndicator(modifier = Modifier.padding(bottom = 16.dp))
        }

        Button(onClick = { userViewModel.loadUserData() }) {
            Text(text = "Load User Data")
        }
    }
}

4. Integrating Compose into the Activity

Compose UI replaces the XML layout. Update MainActivity:

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.lifecycle.viewmodel.compose.viewModel

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            // Jetpack Compose UI
            MaterialTheme {
                MainScreen() // Compose UI Function
            }
        }
    }
}

5. Adding Dependencies

Ensure your build.gradle includes the required dependencies for Compose:

dependencies {
    implementation "androidx.compose.ui:ui:1.6.0"
    implementation "androidx.compose.material3:material3:1.2.0"
    implementation "androidx.lifecycle:lifecycle-viewmodel-compose:2.6.1"
}

5. Best Practices with Coroutines in Android

  1. Use ViewModelScope and LifecycleScope
    Always tie coroutines to the lifecycle to prevent memory leaks.

  2. Handle Exceptions
    Use try-catch blocks or CoroutineExceptionHandler for robust error handling.

  3. Optimize with Dispatchers

    • Dispatchers.IO: For I/O-bound tasks (e.g., network or database).
    • Dispatchers.Main: For UI updates.
    • Dispatchers.Default: For CPU-intensive tasks.

Example: 

viewModelScope.launch(Dispatchers.IO) {
    val data = fetchUserData()
    withContext(Dispatchers.Main) {
        userData.value = data
    }
}

6. Conclusion

Coroutines simplify asynchronous programming in Android by providing a cleaner and more readable syntax. Paired with Jetpack Compose, they enable developers to create efficient, responsive, and modern apps. Whether you're handling network requests or updating a database, coroutines let you focus on logic without worrying about threading complexities.

💡 Start integrating coroutines and Jetpack Compose into your Android projects today for a seamless development experience! 🚀

Integrating a C++ Library into Your React Native Project 1024 1024 w@gner

Integrating a C++ Library into Your React Native Project

Using native code, especially C++, can be an excellent way to enhance your React Native app by leveraging performance-critical logic or existing C++ libraries. This guide will walk you through setting up a C++ library in a React Native project using a development build.

Requirements

Before you start, make sure you have the following:

  • React Native CLI installed (since the managed Expo Go app does not support custom native code).
  • Development Build configuration for Expo, if you’re using Expo.
  • A basic understanding of JNI (Java Native Interface) if you're working with Android, or bridging concepts if you're working with iOS.

Step 1: Set Up Your React Native Project

First, create a new React Native project (if you haven’t already):

npx react-native init MyApp
cd MyApp

For Expo projects, you would need to create a development build. Check Expo’s Development Build Documentation for details.

Step 2: Add Your C++ Library

  1. Create a New Folder for Native Code: Inside your project, add a folder for the C++ files, e.g., cpp/.

  2. Add Your C++ Code: Inside the cpp/ folder, create a C++ file (e.g., MyLibrary.cpp). This file will contain the native code you want to use in React Native.

    // cpp/MyLibrary.cpp
#include 

extern "C"
JNIEXPORT jint JNICALL
Java_com_myapp_MyModule_addNumbers(JNIEnv* env, jobject obj, jint a, jint b) {
   return a + b;
}

Step 3: Configure Android to Use the C++ Library

  1. Update build.gradle: Add NDK support in your Android project if not enabled. Open android/app/build.gradle and add the following under defaultConfig:

    externalNativeBuild {
   cmake {
       cppFlags "-std=c++17"
   }
}
ndk {
   abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64" // Customize as needed
}

  2. Configure CMake: Create a CMakeLists.txt file in your project’s root directory or the cpp/ directory.

    # CMakeLists.txt
cmake_minimum_required(VERSION 3.4.1)

add_library( # Sets the name of the library.
            mylibrary

            # Sets the library as a shared library.
            SHARED

            # Provides the relative path to your source file(s).
            cpp/MyLibrary.cpp )

find_library( # Sets the path to the log library.
             log-lib
             log )

target_link_libraries( # Links your native library with the log library.
                      mylibrary
                      ${log-lib} )

  3. Update Android Native Code Bridge: To expose this method to JavaScript, create a native module. Add a new file, MyModule.java, in android/app/src/main/java/com/myapp/:

    // android/app/src/main/java/com/myapp/MyModule.java
package com.myapp;

import androidx.annotation.NonNull;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.Promise;

public class MyModule extends ReactContextBaseJavaModule {
   static {
       System.loadLibrary("mylibrary"); // Loads the C++ library
   }

   @NonNull
   @Override
   public String getName() {
       return "MyModule";
   }

   @ReactMethod
   public void addNumbers(int a, int b, Promise promise) {
       promise.resolve(addNumbersJNI(a, b));
   }

   public native int addNumbersJNI(int a, int b);
}

    Register the module in MainApplication.java under getPackages to ensure React Native can use it.

Step 4: Write the JavaScript Bridge

  1. In your React Native code, create a JavaScript file to wrap the native module:

    // MyModule.js
import { NativeModules } from 'react-native';
const { MyModule } = NativeModules;

export const addNumbers = (a, b) => MyModule.addNumbers(a, b);

  2. Now, you can use addNumbers in your React Native code:

    import React, { useState } from 'react';
import { Button, Text, View } from 'react-native';
import { addNumbers } from './MyModule';

const App = () => {
   const [result, setResult] = useState(null);

   const handleAddNumbers = async () => {
       const sum = await addNumbers(5, 10);
       setResult(sum);
   };

   return (

Step 5: Build and Run Your App

Finally, you need to rebuild the Android project to link the native code:

cd android
./gradlew clean
cd ..
npx react-native run-android

If using Expo with development builds, make sure your build reflects these changes. For more details, refer to Expo’s Development Builds documentation.

With this setup, you’ve successfully integrated a C++ library in your React Native project, enabling you to call native C++ functions directly from JavaScript. This opens up possibilities for using optimized C++ code, accessing hardware-accelerated libraries, or reusing existing C++ code in your React Native app.

Mastering Mobile Security and Data Encryption for iOS, Android, React Native, and Flutter 1024 1024 w@gner

Mastering Mobile Security and Data Encryption for iOS, Android, React Native, and Flutter

In today's digital landscape, ensuring the security of mobile applications is paramount. With threats continuously evolving, mobile app developers must employ robust encryption techniques and secure authentication methods to protect user data and communication. Whether developing for iOS, Android, React Native, or Flutter, integrating security at the core of your mobile app is not just a feature—it’s a necessity. In this post, we’ll explore key approaches to data security, encryption, and secure authentication, as well as the tools and frameworks available for building secure mobile applications across different platforms.

Data Encryption and Security in Mobile Applications

Data encryption ensures that sensitive information such as user credentials, payment details, or any other private data is safeguarded, even if an unauthorized party intercepts it. On mobile devices, encrypting both data at rest and in transit is vital.

iOS Encryption Mechanisms

Apple’s iOS provides strong built-in encryption mechanisms and frameworks for developers. Here are some of the key features:

  1. Data Protection API: iOS devices use hardware-backed encryption to secure files. By default, all files in iOS are encrypted, but developers can enhance security by leveraging classes like NSFileProtectionComplete, which ensures that data is only accessible when the device is unlocked.

  2. Keychain Services: Securely store small bits of sensitive information, like user credentials or cryptographic keys, with the Keychain. Apple provides APIs for securely accessing and managing these secrets.

  3. CommonCrypto and CryptoKit: Apple’s CommonCrypto and CryptoKit frameworks enable developers to implement encryption algorithms such as AES (Advanced Encryption Standard), RSA, and SHA (Secure Hash Algorithm). With CryptoKit, developers can easily handle public and private keys, encrypt data, and verify digital signatures.

Android Encryption Mechanisms

Android offers a flexible and powerful encryption suite. Developers should make use of the following:

  1. Android Keystore System: Similar to the iOS Keychain, the Android Keystore allows you to store cryptographic keys securely, isolated from the rest of the OS. This protects sensitive data from being accessed by other apps or processes.

  2. Encryption Libraries: Android's javax.crypto package provides a comprehensive suite of encryption algorithms, including AES, RSA, and HMAC (Hash-based Message Authentication Code). The Cipher class can be used to perform encryption and decryption operations on sensitive data.

  3. Enforced File Encryption: Android enforces file encryption at the device level from Android 7.0 (Nougat) onward, securing data at rest. Developers can also implement additional layers of encryption using classes like CipherOutputStream.

React Native Encryption Mechanisms

React Native, being a cross-platform framework, allows developers to implement encryption consistently across iOS and Android. Here are some options:

  1. react-native-keychain: Provides access to both iOS Keychain and Android Keystore for secure storage of sensitive data like tokens, passwords, or cryptographic keys.

  2. crypto-js: This popular library enables developers to perform AES, SHA, and HMAC encryption within a React Native app. It provides a consistent encryption interface for both iOS and Android.

  3. react-native-encrypted-storage: An excellent tool for secure storage of encrypted data, this library ensures data stored locally in both iOS and Android environments is encrypted.

Flutter Encryption Mechanisms

Flutter, Google’s UI toolkit for building natively compiled apps for mobile, offers powerful security features for both iOS and Android platforms. Some options include:

  1. flutter_secure_storage: This plugin provides secure storage using Keychain on iOS and Keystore on Android. It's one of the most secure ways to store sensitive data like authentication tokens and cryptographic keys.

  2. encrypt: This library helps in applying AES and RSA encryption for data security in Flutter apps. It offers a simple API for encrypting and decrypting text and files.

  3. PointyCastle: A versatile cryptography library that supports various encryption algorithms, including AES and RSA, allowing developers to apply strong cryptographic principles to protect sensitive data in Flutter apps.

Authentication Methods for Mobile Applications

Authentication is the first line of defense when securing mobile applications. Whether using traditional username/password combinations, biometrics, or token-based systems, developers must ensure that authentication is as seamless and secure as possible.

Secure Authentication in iOS

  1. Touch ID and Face ID: With iOS’s biometric authentication, developers can integrate secure authentication using Face ID and Touch ID through the LocalAuthentication framework. This is a highly secure, user-friendly way to authenticate users.

  2. OAuth2 with AppAuth-iOS: When integrating with third-party services, OAuth2 is one of the most widely used authentication frameworks. AppAuth-iOS is a robust framework for handling OAuth2 workflows, such as token-based authentication for secure API access.

  3. Certificate-Based Authentication: For highly secure apps, developers can use SSL/TLS certificates to authenticate users. URLSession and Alamofire make it easy to implement certificate pinning, ensuring the app only communicates with trusted servers.

Secure Authentication in Android

  1. Fingerprint and Biometric Authentication: Android’s BiometricPrompt API allows developers to implement fingerprint and face authentication easily. Starting with Android 9.0 (Pie), the API ensures a consistent and secure way to authenticate users biometrically.

  2. OAuth2 with AppAuth-Android: Similar to iOS, OAuth2 can be implemented using AppAuth-Android for secure API interactions. This open-source library simplifies token management, client authentication, and OAuth2 flows.

  3. SMS Retriever API: Google’s SMS Retriever API allows apps to retrieve SMS messages containing OTP (one-time passwords) without requiring explicit SMS permission. This is a secure and user-friendly way to handle 2-factor authentication.

Secure Authentication in React Native

  1. React Native Biometrics: This library simplifies the process of integrating biometric authentication (fingerprint, Face ID) in React Native apps. It works seamlessly across both iOS and Android.

  2. OAuth2: For token-based authentication, developers can use the react-native-app-auth library, which is a wrapper around the AppAuth libraries for both platforms. It supports secure, modern authentication flows such as OAuth2 and OpenID Connect.

  3. 2FA with react-native-sms-retriever: This library provides an easy-to-use interface for OTP retrieval via SMS, improving the security and usability of two-factor authentication (2FA).

Secure Authentication in Flutter

  1. flutter_local_auth: This package provides biometric authentication using Face ID, Touch ID, or fingerprint scanning on both iOS and Android. It seamlessly integrates secure, user-friendly authentication mechanisms into Flutter apps.

  2. OAuth2 in Flutter: Using libraries like flutter_appauth, developers can securely implement OAuth2 workflows, including token-based authentication, for secure interactions with APIs.

  3. Firebase Authentication: Flutter’s integration with Firebase Authentication simplifies the process of setting up email, password, and social logins while ensuring security with methods such as phone authentication, passwordless logins, and multi-factor authentication.

Secure Communication Between Client and Server

Beyond data encryption and authentication, securing the communication between mobile apps and backend servers is crucial.

  1. SSL/TLS and HTTPS: All communication between the mobile client and the server should be over HTTPS, secured with SSL/TLS. Developers should ensure SSL pinning is in place, preventing man-in-the-middle (MITM) attacks by verifying the server’s SSL certificate.

  2. End-to-End Encryption (E2EE): For apps where privacy is critical (e.g., messaging apps), end-to-end encryption is essential. This ensures that data remains encrypted throughout the transmission and can only be decrypted by the intended recipient.

  3. Network Security Configuration (Android): Android developers can specify network security settings in the app’s manifest, such as enforcing HTTPS for all traffic, adding an extra layer of protection.

  4. Certificate Pinning: Both iOS and Android offer certificate pinning techniques to ensure that an app only communicates with trusted servers, minimizing the risk of MITM attacks.

Security Testing and Tools for Mobile Applications

Security testing is vital to ensure that mobile applications are resistant to potential threats. Here are some useful tools and frameworks for security testing:

  1. OWASP Mobile Security Testing Guide (MSTG): A comprehensive guide for testing mobile applications, with best practices and security requirements for iOS, Android, React Native, and Flutter.

  2. ZAP (Zed Attack Proxy): An open-source tool for security testing mobile APIs and web services, ensuring that communication between client and server is secure.

  3. MobSF (Mobile Security Framework): A popular tool for performing static and dynamic analysis of Android, iOS, React Native, and Flutter apps. It helps identify potential security vulnerabilities before app release.

Conclusion

In the ever-changing landscape of mobile development, security cannot be an afterthought. Whether building on iOS, Android, React Native, or Flutter, developers must prioritize data encryption, secure authentication, and robust communication protocols. Leveraging the right tools and frameworks is essential to delivering secure mobile applications that protect user data and ensure privacy. By implementing best practices in security, you not only protect your users but also build trust and a competitive edge in the marketplace.

Android 12 launched 500 300 assiswagner

Android 12 launched

The tech giant Google has announced Android 12, which is promoting an updated UI and many other new features. However, the update is expected to be ready only by the end of the year in its final version.

Some users can download the Android 12 beta now, including anyone with a Pixel 3 or later, as well as owners of the Xiaomi Mi 11, OnePlus 9, and some other similar models.

If you have another Android phone, you'll likely have to wait a bit longer, as Android 12 needs to be adapted to the phone before it can run, but the wait will be worth it!

What's New in Android 12

Android 12 is the 2021 update to Google's Android operating system, based on Android 11 released in 2020. Google describes this update as the biggest design change in Android's history.

Updated UI

Google has announced a new Material Design language for Android 12, called Material You, which is a revamp of the entire UI across the operating system. The current beta brings more rounded buttons, more varied colors, smoother movements and animations, and much more.

The company calls this color extraction, where you can choose a wallpaper and the system will automatically apply the dominant, complementary, and best-looking colors to the rest of the UI, including the notification shade, lock screen, and volume controls.

Widgets have also been redesigned, looking much more rounded this time. Due to iOS 14 introducing widgets last year, it made sense for Android 12 to see a redesign in this area as well.

Privacy and Security

This year, Google has made it a point to ensure that privacy is at the heart of Android 12. The Android Private Compute Core is the engine behind Android 12's privacy features, ensuring that apps and the phone adhere to the privacy settings enabled by you.

The new privacy dashboard provides an overview of apps using the phone's location, camera, contacts, and more. A nice touch here is a simple overview in the form of a pie chart, showing what apps have accessed in the last 24 hours.

The notification center also has a quick toggle to disable all features of the phone that an app is using. For example, if Facebook is using the microphone while you're using another app, this part of the notification center will explicitly show that Facebook is using the microphone. Pressing this will disable its use in Facebook and other apps, if desired.

You can also choose to provide only an approximate location for some apps, like weather apps, which don't need to know exactly where you are.

And with features like Live Caption, Now Playing, and Smart Reply, all audio and language processing happens on your device, so the data isn't sent elsewhere.

There are also locked folders available in apps, allowing you to lock a specific folder with a fingerprint, and there's the ability to unlock a Chromebook using your phone. 

New Features

When pressed, the power button now launches Google Assistant, a much easier method to call up the service for a query when needed.

A new integrated remote control is now also standard in Android 12, so if you have a TV that runs on Android, or just a Chromecast, you can use your phone to watch your favorite shows.

Compatibility

Google has confirmed that it will prepare Android 12 to be more flexible with third-party app stores and installers like the Amazon App Store, APKUpdater, and Samsung Galaxy Apps.

As for smartphone models, Android 12 will likely be released on most models from the past two years. However, it is guaranteed to arrive on all modern Pixel devices, likely starting from the Pixel 3, as these models support the beta.