Forem: Sandeep Satpute

ARCore For Android

Sandeep Satpute — Sun, 07 Apr 2024 11:46:17 +0000

Introduction
In this post, I would like to introduce a simple way to display 3D models supported by native Android. However. 3D models can be displayed in AR in a variety of ways. Using Scene Viewer with intents directly from your Android native app is one of those methods. In this topic will see how we can display the model using Explicit Intent and Scene viewer.

Using Scene Viewer
Scene Viewer is an immersive viewer that enables 3D and AR experiences from your website or Android app. It lets users of Android mobile devices easily preview, place, view, and interact with web-hosted 3D models in their environment.

Launch Scene Viewer Using an Explicit Intent to Google Play Services for AR
Google Play Services for AR is used to power the AR functionality in Scene Viewer.
You can use an explicit Android intent from a website or native Android app to launch Scene Viewer via the com.google.ar.core package and supply a browser fallback URL to ensure that AR is supported in Scene Viewer. Using Scene Viewer, you can ensure that every user either has a native AR experience or a fallback experience you have created yourself. You may create a gracious error message or your 3D viewer as examples of fallback experiences.

Scene Viewer Using an Explicit Intent Example

val sceneViewerIntent = Intent(Intent.ACTION_VIEW)
            val intentUri =
                Uri.parse("https://arvr.google.com/scene-viewer/1.0").buildUpon()
                    .appendQueryParameter("file", "https://storage.googleapis.com/ar-answers-in-search-models/static/Tiger/model.glb")    //Working
                    .appendQueryParameter("mode", "ar_only")
                    .appendQueryParameter("title", "Tiger")
                    .build()
            sceneViewerIntent.data = intentUri
            sceneViewerIntent.setPackage("com.google.ar.core")
            sceneViewerIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
            startActivity(sceneViewerIntent)

Github Link
https://github.com/SandeepSatpute9271/Simple_AR

Android Developer Roadmap 2024

Sandeep Satpute — Mon, 11 Dec 2023 17:58:49 +0000

Hey folks, here's a general Android Development Roadmap. This Android development roadmap will provide you with a comprehensive overview of the skills and knowledge you'll need to succeed in the ever-evolving world of Android development. We all know that the field of technology is dynamic and constantly evolving, so it's important to check the official documentation and other reputable sources for the latest updates

Fundamentals
Programming Language

Kotlin: Kotlin is the official language for Android development and is essential for any aspiring Android developer.
Java: While Kotlin is the preferred language, Java is still widely used, and understanding it can be beneficial.

Android SDK

Android Studio: The official IDE for Android development.
Android APIs: Familiarize yourself with the core Android APIs and frameworks.

Database Design

SQL: Learn the basics of SQL for data storage and retrieval.
Room: A powerful library for managing SQLite databases in Android.

Intermediate
Jetpack libraries

Compose: A modern UI framework for building declarative and reactive user interfaces.
ViewModel: Store and manage UI data.
LiveData: Observe changes in data and update the UI automatically.
Navigation: Manage navigation within your app.

Networking

Retrofit: A popular library for making HTTP requests.
OkHttp: A powerful HTTP client with advanced features.

Security

Android Keystore: Securely store sensitive data such as encryption keys and passwords.
Biometric Authentication: Enable fingerprint and face unlock for secure user authentication.

Testing

JUnit: Unit testing framework for Android.
Espresso: UI testing framework for Android.

Advanced

Machine Learning
TensorFlow Lite: On-device machine learning library for Android.
ML Kit: Firebase ML Kit provides pre-trained models for common machine learning tasks.
ARCore: Develop augmented reality experiences for Android devices.
Jetpack Compose Multiplatform: Build cross-platform apps for Android and iOS using Jetpack Compose.
Kotlin Coroutines: Asynchronous programming with Kotlin coroutines.
Clean Architecture: Design principles for building maintainable and scalable apps.
Jetpack Compose for Wear OS: Build watch faces and apps for Wear OS devices.

Extras

Stay up-to-date with the latest news and trends: Follow Android blogs and attend conferences to learn about the latest advancements.
Practice regularly: The best way to learn is by doing. Build small projects to practice your skills and get comfortable with the Android development tools.
Contribute to open source projects: This is a great way to gain experience and learn from other developers.
Forums and Communities: Join online forums and communities to connect with other developers and learn from their experiences.

Resources(R.string) in viewModel in Android

Sandeep Satpute — Fri, 05 Aug 2022 17:09:19 +0000

I would like to share a technique to access the strings in view model that works well.
So there are multiple ways to access the string in view model but they have there own advantages and disadvantages.
We have options like

Hardcode a string in code but this will not help in case of reusability and string localisation
Use the context of an activity but in mvvm its bad practice to use context direct in view model
Return the string resource id which is integer and in activity get the actual string but this will increase the efforts

Let's move toward the solution
In MVVM and hilt will have addition benefits to overcome above issue.

We will add the StringResourcesProvider.kt

@Singleton
class StringResourcesProvider @Inject constructor(
    @ApplicationContext private val context: Context
) {
    fun getString(@StringRes stringResId: Int): String {
        return context.getString(stringResId)
    }
}

Define the view model to get the string

@HiltViewModel
class AuthViewModel @Inject constructor(
    private val stringResourcesProvider: StringResourcesProvider
) : ViewModel() {
    ...
    fun validate() {
        val username: String = stringResourcesProvider.getString(R.string.username)
    }
    ...
}

In this way we can access the string in view model or any other places.

Thanks for reading my post.
Happy codding

Shared ViewModel: A modern way to share data between android fragments and activities

Sandeep Satpute — Sun, 10 Jul 2022 18:42:38 +0000

In android development, developer multiple time come across a situation where needs to share the data between fragments and activities. So there are multiple ways to share the data between fragments and activities such as

Bundle while replacing the fragment/activity
By using interface
Shared viewModel

Let's start with shared viewModel which is the simplest way of sharing the data between fragments/activities.

What is viewModel and responsibility of viewModel
The ViewModel class is designed to store and manage UI-related data in a lifecycle-conscious way. ViewModel class acts as an interface between Fragments to sharing data.
ViewModel Life cycle helps us to hold the data and keep that live even if fragment is replaced.

Shared viewModel
The shared view model is the normal view model only but the data holding behaviour and life cycle of view model help us to make it shared view model.
As per life cycle data is available even if caller fragment get destroy and we can get that data for other fragments.

Example

Sender Fragment



override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        model = ViewModelProvider(requireActivity()).get(SharedViewModel::class.java)
        button.setOnClickListener { model.sendMessage("Techno Learning") }
    }

Receiver Fragment



override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val model = ViewModelProvider(requireActivity()).get(SharedViewModel::class.java)
        model.message.observe(viewLifecycleOwner, Observer {
            textViewReceiver.text = it
        })
    }

Precaution: Create SharedViewModel using the same owner.

Git Repository Link

Conclusion
We learned about Shared ViewModel in Android to communicate with other fragments. Hope you enjoyed this blog.

Happy Learning

Kotlin Multiplatform Mobile (KMM)

Sandeep Satpute — Mon, 23 May 2022 09:18:41 +0000

Basics about the KMM

Kotlin Multiplatform Mobile (KMM) is an SDK that allows us to use the same business logic code in both iOS and Android applications. It offers all the combined benefits of creating cross-platform and native apps. It reduces the time needed for writing and maintaining the same code for different mobile platforms while retaining the flexibility and benefits of native programming. With Kotlin, we can use a single codebase for the business logic of iOS and Android apps and write platform-specific code only where necessary in order to implement a native UI or when working with platform-specific APIs.

Benefits

Share code for logic elements that often fall out of sync while keeping the advantages of native programming, including great app performance and full access to the Android and iOS SDKs.

How KMM works

An app consists of 4 main layers that includes UI logic layer, presentation logic layer, business logic layer, and data Layer. The data layer which has classes with the responsibility of making network calls and database queries can be 100% shared. The presentation and UI logic can be partially shared depending upon the device types and other platform specific peculiarities.

KMM can seamlessly be integrated with the mobile project. Shared code, written in Kotlin, is compiled to JVM bytecode with Kotlin/JVM and to native binaries with Kotlin/Native, so you can use your KMM business-logic modules just like any other regular mobile library.

Kotlin harbours multiplatform libraries that can reuse the multiplatform logic in common and platform-specific code such as HTTP, Serialization etc. To interoperate with platforms, platform-specific versions of Kotlin can be used. Platform-specific versions of Kotlin (Kotlin/JVM, Kotlin/JS, Kotlin/Native) include extensions to the Kotlin language, and platform-specific libraries and tools. Through these platforms one can access the platform native code (JVM, JS, and Native) and leverage all native capabilities.

Case studies

Quizlet migrated their business logic from a shared JavaScript approach to KMM and drastically improved the performance of both their Android and iOS applications.
Fastwork introduced KMM for the domain and data layers of their application to share business logic and API service between mobile platforms, significantly boosting their team’s productivity.
Yandex.Disk started out by experimenting with the integration of a small feature, and when the experiment proved successful, they implemented their whole data synchronization logic in KMM.
Also, there are big projects that are using KMM in production ( i.e Netflix, Phillips, and more ) and probably it was not mentioned but Unit Testing is also possible using KMM.

The project structure

As you can see below, the project is divided into three modules:

androidApp—contains all the native code for the Android application
iosApp—contains all the native code for the iOS application
shared—contains all the shared code (eg business logic) to be used in both the Android and iOS platform

Benefits of using KMM

Reduced development time and effort
Improved code quality
No Impact on performance
Easy to use
UI can be split for each target platform – the app will feel consistent with any given ecosystem
Shared logic allows developers to add new features and fix bugs on both operating systems at the same time
Easy to integrate: Whether it’s a fresh project or already existing project you can start integrating KMM anytime.
Easy to learn: Kotlin syntax is very similar to other popular languages such as Swift and Java. So it’s pretty easy to learn and get started with KMM.

Finish line!

And that's it for now. KMM is a good option if there is something that needs to be shared on different mobile platforms, as new options there are limitations that progressively will be fixed.

Kotlin is an awesome language and Kotlin Multiplatform brings that to other platforms to help us create scalable and maintainable apps using a single codebase. Although the code-sharing is slightly less than that with other cross-platform solutions as UI cannot be shared, that gives us the advantage of creating a user experience that is in line with the platform’s guidelines and best practices.

Basically think about KMM as a new option to share code between platforms that will be improved by the Kotlin community and you have the control of what needs to be shared and what’s not.

Let’s Kotlin!