Cannot find symbol return DaggerApplication_HiltComponents_SingletonC.builder()

I switched to Hilt dependency injection this morning. After everything is done, then I stuck with this one:

error: cannot find symbol return DaggerMyApplication_HiltComponents_SingletonC.builder() ^ symbol: variable DaggerMyApplication_HiltComponents_SingletonC

I did try to find the solution my self and I found this one, but I already added all module’s build.gradle Please take a look at mine if I did anything wrong.

My application:

class MyApplication : MultiDexApplication() 

Project Gradle:

dependencies {
    classpath ''
    classpath ''
    classpath ''
    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    // NOTE: Do not place your application dependencies here; they belong
    // in the individual module build.gradle files

App Gradle:

implementation ''
kapt ''
implementation "androidx.hilt:hilt-lifecycle-viewmodel:1.0.0-alpha03"
kapt 'androidx.hilt:hilt-compiler:1.0.0-beta01'

enter image description here Thank you all


In my case this error caused by androidx.hilt:hilt-lifecycle-viewmodel dependency

According to Dagger Hilt Github comments:

implementation "androidx.hilt:hilt-lifecycle-viewmodel"
kapt "androidx.hilt:hilt-compiler"

should be removed.

see this, also this


How to resolve “Missing PendingIntent mutability flag” lint warning in android api 30+?

As soon as I updated the target SDK to 30 (Android R), a lint warning Missing PendingIntent mutability flag appeared on my PendingIntent.FLAG_UPDATE_CURRENT flag when I want to define PendingIntent.

How should I handle this lint with no effect on the app functionality?


You can set your pending intent as

val updatedPendingIntent = PendingIntent.getActivity(
   PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT // setting the mutability flag 

According to the docs here:

Strongly consider using FLAG_IMMUTABLE, only use FLAG_MUTABLE if some functionality depends on the PendingIntent being mutable, e.g. if it needs to be used with inline replies or bubbles.

Choose your flag accordingly.

If you want to read more about this i would suggest that you read this great article here:


Redux createAsyncThunk vs useEffect hook

I’m familiar with react hooks, and i find it really easy to work with useEffect, thunk is very difficult to deal with, can i just use useEffect & axios and just dispatch the result to the store without using createAsyncThunk? is there any major performance benefit to use it over useEffect?


import { createAsyncThunk, createSlice } from '@reduxjs/toolkit'
import { userAPI } from './userAPI'

// First, create the thunk
const fetchUserById = createAsyncThunk(
  async (userId, thunkAPI) => {
    const response = await userAPI.fetchById(userId)

// Then, handle actions in your reducers:
const usersSlice = createSlice({
  name: 'users',
  initialState: { entities: [], loading: 'idle' },
  reducers: {
    // standard reducer logic, with auto-generated action types per reducer
  extraReducers: {
    // Add reducers for additional action types here, and handle loading state as needed
    [fetchUserById.fulfilled]: (state, action) => {
      // Add user to the state array

// Later, dispatch the thunk as needed in the app


import React, { useEffect } from 'react';
import { useDispatch } from 'react-redux'
import { userAPI } from './userAPI'
import axios from 'axios';
function App() {  
const dispatch = useDispatch()
useEffect(() => {
  .then(response => dispatch({type:'fetchUsers',}));
    }, []);


The two setups are essentially similar. You can do the same thing with both approaches.

With the codes exactly as you have them written here, there is a major advantage to the createAsyncThunk approach because it will catch any errors that occur in the API call. It will respond to those errors by dispatching a fetchUserById.rejected action instead of a fetchUserById.fulfilled action. Your reducer doesn’t responded to the rejected case which is fine. The error is still caught. With your useEffect you run the risk of “uncaught error in Promise” errors.

Now of course you can catch the errors on your own. You can also dispatch a pending action at the start of the effect. But once you start doing that, the createAsyncThunk might feel a lot easier by comparison since it automatically dispatches pending, fulfilled, and rejected actions.

useEffect(() => {
  dispatch({ type: "fetchUsers/pending" });
    .then((response) =>
      dispatch({ type: "fetchUsers", payload: })
    .catch((error) =>
      dispatch({ type: "fetchUsers/rejected", payload: error.message })
}, []);
Source: stackoverflow
Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may apply. By using this site, you agree to the Privacy Policy, and Copyright Policy. Content is available under CC BY-SA 3.0 unless otherwise noted. The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 © No Copyrights, All Questions are retrived from public domain..