How to Fix issue of SSL Handshake Exception on Android

Enya Emmanuel — Thu, 10 Jun 2021 21:58:44 +0000

Recently I was working on a chat application for the android platform, everything regarding the remote/networking implementation worked flawlessly. I used the Retrofit networking library and socket.io. At the time, the base url was without SSL (that is the HTTP scheme - http://api.example.com)

Just before we rolled out the MVP for beta testing, we acquired a domain name and enabled SSL on the server. This meant the base URL scheme became HTTPS (e.g https://api.example.com).

The change on the app to use a secured URL broke the entire app. All the endpoints were not connecting to the server successfully. Basically the network handshake process between the client and server wasn't successful. Below is what the the error on the log was like



<-- HTTP FAILED: javax.net.ssl.SSLHandshakeException: java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.

After doing a little research I discovered it was an issue with the server certificate not being trusted by the android system. This could be because of any of the reasons below:

The Certificate Authority (CA) that issued the server certificate was unknown.
The server certificate wasn't signed by a CA, but was self signed.
The server configuration is missing an intermediate CA.

In my case, this issue existed because the server certificate was self signed.

From android documentation there is a clean way to configure the app to trust your own self-signed certificates, which I will outline in 3 steps.

Step 1

Add the crt file to the raw folder.

This file will be retrieved from the server. You can request for the digital certificate from the backend engineer. It should come in a .crt extension.

Step 2

Create an XML network security config file (network_security_config.xml) like below:

network_security_config.xml



<?xml version="1.0" encoding="utf-8"?>

<network-security-config>

    <domain-config>

        <domain includeSubdomains="true">api.example.com</domain>

        <trust-anchors>

            <certificates src="@raw/certificate" />

        </trust-anchors>

    </domain-config>

</network-security-config>

Step 3

Specify the network configuration settings in the Manifest.xml file of your application.

With these 3 steps done, you should connect seamlessly with the backend without any further issues.

How to set up a Base Fragment Class with ViewBinding and ViewModel on Android

Enya Emmanuel — Wed, 07 Apr 2021 07:32:54 +0000

Hey guys! This is my first article on dev.to, and I am super excited about writing again after a long while. Quickly, let's get into the subject at hand.

Building native Android apps require you have a fair knowledge of object-oriented programming. This forms the basis for this article because we will leverage the concepts of Inheritance to set up a base class. In addition to this, you’ll learn about generics, with practical examples.

One may be curious as to why we would want to add another layer of inheritance to our fragment class? This question is usually common with beginner programmers yet to realize the benefits of inheritance.

What is Inheritance in Object-Oriented Programming (OOP)?

Inheritance is a feature in which a class inherits all the features of another class. The class from which the features are inherited is known as the base class, superclass, or parent class, and the class that inherits the features is known as a derived class, subclass, or child class.

E.g. If Class D extends A, it is inheriting the features of A.

What are Generics?

Generics are simply parameterized types. The idea is to allow type (Integer, String, … etc, and user-defined types) to be a parameter to methods, classes, and interfaces. Using Generics, it is possible to create classes that work with different data types.

Enough theory, let's get started on creating a base fragment class.

STEP 1:

Create a class BaseFragment that extends a Fragment

abstract class BaseFragment<VBinding : ViewBinding, ViewModel : BaseViewModel> : Fragment() {

    open var useSharedViewModel: Boolean = false

    protected lateinit var viewModel: ViewModel
    protected abstract fun getViewModelClass(): Class<ViewModel>

    protected lateinit var binding: VBinding
    protected abstract fun getViewBinding(): VBinding

    private val disposableContainer = CompositeDisposable()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        init()
    }

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        setUpViews()
        observeData()
    }

    open fun setUpViews() {}

    open fun observeView() {}

    open fun observeData() {}

    private fun init() {
        binding = getViewBinding()
        viewModel = if (useSharedViewModel) {
            ViewModelProvider(requireActivity()).get(
                getViewModelClass()
            )
        } else {
            ViewModelProvider(this).get(getViewModelClass())
        }
    }

    fun Disposable.addToContainer() = disposableContainer.add(this)

    override fun onDestroyView() {
        disposableContainer.clear()
        super.onDestroyView()
    }
}

abstract class BaseFragment<VBinding : ViewBinding, ViewModel : BaseViewModel> : Fragment()

Basically what we've done here is create a BaseFragment which accepts two types, that is a ViewBinding and a ViewModel. With this class, we move common logic and set up to one place, thereby reducing duplicate codes (boilerplates).

The ViewModel class and the ViewBinding object specified as fields in the base class will be provided by the subclass when getViewModelClass() and getViewBinding() are invoked, respectively.

open fun setUpViews() {} and open fun observeData() {} are methods with a default empty implementation. This makes it optional for its sub-classes to override. The subclasses are not forced to override these methods.

STEP 2:

With the base class set up, we'll use it by creating another fragment class that extends BaseFragment.


@AndroidEntryPoint
class UserListFragment : BaseFragment<FragmentUserListBinding, UserViewModel>() {

    override var useSharedViewModel = true

    override fun getViewModelClass() = UserViewModel::class.java

    override fun getViewBinding() = FragmentUserListBinding.inflate(layoutInflater)

    override fun setUpViews() {

        // set up recycler view and bind data to UI
    }

}

From the code block above, we have been able to achieve a simple and readable fragment class, using the concepts of inheritance and generics.

In summary,

Using a base fragment helps you avoid code and pattern repetition.
You achieve a clean and readable code with the concepts discussed in this article.

That is it for this article. Please share your thoughts on this subject.

Forem: Enya Emmanuel