Ssl Certificate Setup

         

 build.gradle

  implementation("com.squareup.retrofit2:retrofit:2.9.0")
  implementation ("com.squareup.retrofit2:converter-gson:2.9.0")
  implementation("com.squareup.okhttp3:logging-interceptor:4.10.0")

  object RetrofitClient {
    private const val BASE_URL = "http://reltrack.vibsugar.com/"

    fun getClient(): ApiService {
        val retrofit = Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            //.client(getSslClient())
            .build()
        return retrofit.create(ApiService::class.java)
    }

    fun getSslClient(): OkHttpClient? {
        var client: OkHttpClient? = null;
        try {
            val trustAllCerts = arrayOf<TrustManager>(object : X509TrustManager {
            override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) {}
            override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) {}
            override fun getAcceptedIssuers(): Array<X509Certificate> = arrayOf()
           })
            val sslContext = SSLContext.getInstance("SSL")
            sslContext.init(null, trustAllCerts, SecureRandom())

            client = OkHttpClient.Builder()
                .sslSocketFactory(sslContext.socketFactory, trustAllCerts[0] as X509TrustManager)
                .hostnameVerifier { _, _ -> true }
                .build()
        } catch (e: Exception) {
            Log.d("SslException", e.message ?: "Unknown error")
        }
        return client
    }
}



interface ApiService {
    @FormUrlEncoded
    @POST("api/WebAPI/GPS_ValidateIMEI")
    suspend fun getVerifyUser(
        @Field("Mobile") mobile:String,
        @Field("IMEI") imei:String,
        @Field("Password") password:String):JsonArray
        
    @POST("api/AtspWebServices/Login")
    suspend fun getLogin(@Body request: JsonObject): LoginResponse
 }
 
sealed class Response<T>(val data: T? = null, val message: String? = null) {
    class Success<T>(data: T) : Response<T>(data)
    class Error<T>(message: String?, data: T? = null) : Response<T>(data, message)
    class Loading<T>() : Response<T>()
}

inline fun <reified T : ViewModel> ComponentActivity.viewModels(): T {
    val context = applicationContext
    val apiService = RetrofitClient.authApiService
    val repository = AppRepository(apiService, context)
    val factory = AppViewModelFactory(repository)
    return ViewModelProvider(this, factory)[T::class.java]
}

inline fun <reified T : ViewModel> Fragment.viewModels(): T {
    val context = requireContext().applicationContext
    val apiService = RetrofitClient.authApiService
    val repository = AppRepository(apiService, context)
    val factory = AppViewModelFactory(repository)
    return ViewModelProvider(this, factory)[T::class.java]
}

class AppViewModelFactory(private val repository: AppRepository) : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return AppViewModel(repository) as T
    }
}

class AppRepository(private val apiService: ApiService, private val applicationContext: Context) {
    suspend fun loginUser(username: String, password: String): Response<UserData> {
        return try {
            if (!isInternetAvailable(applicationContext)) {
                return Response.Error("No internet connection.")
            }
            val request = JsonObject().apply {
                addProperty("mobile", username)
                addProperty("password", password)
            }
            val response = apiService.getLogin(request)
            return if (response.STATUS == "OK" && response.User != null) {
                Response.Success(response.User)
            } else {
                Response.Error(response.MSG)
            }
        } catch (e: Exception) {
            Response.Error(e.localizedMessage ?: "Something went wrong.")
        }
    }
}

class AppViewModel(private val repository: AppRepository) : ViewModel() {
    private val _userData = MutableLiveData<Response<UserData>>()
    val userData: LiveData<Response<UserData>> get() = _userData
    fun getLogin(mobile: String, password: String) {
        viewModelScope.launch(Dispatchers.IO) {
            _userData.postValue(Response.Loading())
            val result = repository.loginUser(mobile, password)
            _userData.postValue(result)
        }
    }
}