"Route not available" for release builds, works in debug

[see-mack]

The app launches fine in debug flavour but fails in the release flavour. Circuit outputs a "Route not available..." error.

Any idea on what could cause the difference between the two flavours?

[ZacSweers]

It's impossible to say without more context

[see-mack]

Appreciate the quick response! I figured there wouldn't be enough context but thought I'd ask in case it happened to be a known gotcha.

What I've found so far, there are some curious differences in the generated files for a debug build vs release build. For one, there's a number of files that aren't generated for the release build:

The generated DaggerAppComponent.java is different between the two flavours too. The release version of the Circuit provider is just an empty set:
this.provideCircuitProvider = CircuitModule_Companion_ProvideCircuitFactory.create(SetFactory.<com.slack.circuit.runtime.presenter.Presenter.Factory>empty(), SetFactory.<com.slack.circuit.runtime.ui.Ui.Factory>empty());
while the debug version is
this.provideCircuitProvider = CircuitModule_Companion_ProvideCircuitFactory.create(setOfPresenterFactoryProvider, setOfUiFactoryProvider);

The release version is also missing a lot of providers compared to the debug version:

Debug:

package io.thisischris.terminal.triplogger.di;

import android.app.Activity;
import android.content.Context;
import com.slack.circuit.foundation.Circuit;
import dagger.internal.DaggerGenerated;
import dagger.internal.Preconditions;
import dagger.internal.SetFactory;
import io.thisischris.terminal.triplogger.MainActivity;
import io.thisischris.terminal.triplogger.MainActivity_Factory;
import java.util.Collections;
import java.util.Map;
import javax.annotation.processing.Generated;
import javax.inject.Provider;

@DaggerGenerated
@Generated(
    value = "dagger.internal.codegen.ComponentProcessor",
    comments = "https://dagger.dev"
)
@SuppressWarnings({
    "unchecked",
    "rawtypes",
    "KotlinInternal",
    "KotlinInternalInJava"
})
public final class DaggerAppComponent {
  private DaggerAppComponent() {
  }

  public static AppComponent.Factory factory() {
    return new Factory();
  }

  private static final class Factory implements AppComponent.Factory {
    @Override
    public AppComponent create(Context context) {
      Preconditions.checkNotNull(context);
      return new AppComponentImpl(context);
    }
  }

  private static final class AppComponentImpl implements AppComponent {
    private final AppComponentImpl appComponentImpl = this;

    private Provider<Circuit> provideCircuitProvider;

    private Provider<MainActivity> mainActivityProvider;

    private AppComponentImpl(Context contextParam) {

      initialize(contextParam);

    }

    @SuppressWarnings("unchecked")
    private void initialize(final Context contextParam) {
      this.provideCircuitProvider = CircuitModule_Companion_ProvideCircuitFactory.create(SetFactory.<com.slack.circuit.runtime.presenter.Presenter.Factory>empty(), SetFactory.<com.slack.circuit.runtime.ui.Ui.Factory>empty());
      this.mainActivityProvider = MainActivity_Factory.create(provideCircuitProvider);
    }

    @Override
    public Map<Class<? extends Activity>, Provider<Activity>> getActivityProviders() {
      return Collections.<Class<? extends Activity>, Provider<Activity>>singletonMap(MainActivity.class, ((Provider) mainActivityProvider));
    }
  }
}

vs release

package io.thisischris.terminal.triplogger.di;

import android.app.Activity;
import android.content.Context;
import com.slack.circuit.foundation.Circuit;
import dagger.internal.DaggerGenerated;
import dagger.internal.DoubleCheck;
import dagger.internal.InstanceFactory;
import dagger.internal.Preconditions;
import dagger.internal.SetFactory;
import io.thisischris.terminal.triplogger.MainActivity;
import io.thisischris.terminal.triplogger.MainActivity_Factory;
import io.thisischris.terminal.triplogger.db.TripDatabase;
import io.thisischris.terminal.triplogger.repo.OdometerRepository;
import io.thisischris.terminal.triplogger.repo.TripRepository;
import io.thisischris.terminal.triplogger.screen.TerminalScreenPresenterFactory;
import io.thisischris.terminal.triplogger.screen.TerminalScreenPresenterFactory_Factory;
import io.thisischris.terminal.triplogger.screen.TerminalScreenPresenter_Factory;
import io.thisischris.terminal.triplogger.screen.TerminalScreenPresenter_Factory_Impl;
import io.thisischris.terminal.triplogger.screen.TerminalScreenUiFactory_Factory;
import io.thisischris.terminal.triplogger.screen.ViewTripsScreenPresenterFactory;
import io.thisischris.terminal.triplogger.screen.ViewTripsScreenPresenterFactory_Factory;
import io.thisischris.terminal.triplogger.screen.ViewTripsScreenPresenter_Factory;
import io.thisischris.terminal.triplogger.screen.ViewTripsScreenPresenter_Factory_Impl;
import io.thisischris.terminal.triplogger.screen.ViewTripsScreenUIFactory_Factory;
import io.thisischris.terminal.triplogger.session.SessionManager;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;

@DaggerGenerated
@Generated(
    value = "dagger.internal.codegen.ComponentProcessor",
    comments = "https://dagger.dev"
)
@SuppressWarnings({
    "unchecked",
    "rawtypes",
    "KotlinInternal",
    "KotlinInternalInJava"
})
public final class DaggerAppComponent {
  private DaggerAppComponent() {
  }

  public static AppComponent.Factory factory() {
    return new Factory();
  }

  private static final class Factory implements AppComponent.Factory {
    @Override
    public AppComponent create(Context context) {
      Preconditions.checkNotNull(context);
      return new AppComponentImpl(context);
    }
  }

  private static final class AppComponentImpl implements AppComponent {
    private final AppComponentImpl appComponentImpl = this;

    private Provider<Context> contextProvider;

    private Provider<OdometerRepository> provideOdomRepositoryProvider;

    private Provider<TripDatabase> provideTripDbProvider;

    private Provider<TripRepository> provideTripRepositoryProvider;

    private Provider<SessionManager> providesSessionManagerProvider;

    private Provider<CoroutineScope> providesCoroutineScopeProvider;

    private TerminalScreenPresenter_Factory terminalScreenPresenterProvider;

    private Provider<io.thisischris.terminal.triplogger.screen.TerminalScreenPresenter.Factory> factoryProvider;

    private Provider<TerminalScreenPresenterFactory> terminalScreenPresenterFactoryProvider;

    private ViewTripsScreenPresenter_Factory viewTripsScreenPresenterProvider;

    private Provider<io.thisischris.terminal.triplogger.screen.ViewTripsScreenPresenter.Factory> factoryProvider2;

    private Provider<ViewTripsScreenPresenterFactory> viewTripsScreenPresenterFactoryProvider;

    private Provider<Set<com.slack.circuit.runtime.presenter.Presenter.Factory>> setOfPresenterFactoryProvider;

    private Provider<Set<com.slack.circuit.runtime.ui.Ui.Factory>> setOfUiFactoryProvider;

    private Provider<Circuit> provideCircuitProvider;

    private Provider<MainActivity> mainActivityProvider;

    private AppComponentImpl(Context contextParam) {

      initialize(contextParam);

    }

    @SuppressWarnings("unchecked")
    private void initialize(final Context contextParam) {
      this.contextProvider = InstanceFactory.create(contextParam);
      this.provideOdomRepositoryProvider = DoubleCheck.provider(OdometerRepositoryModule_ProvideOdomRepositoryFactory.create(contextProvider));
      this.provideTripDbProvider = DoubleCheck.provider(DbModule_ProvideTripDbFactory.create(contextProvider));
      this.provideTripRepositoryProvider = DoubleCheck.provider(DbModule_ProvideTripRepositoryFactory.create(provideTripDbProvider));
      this.providesSessionManagerProvider = DoubleCheck.provider(SessionManagerModule_ProvidesSessionManagerFactory.create());
      this.providesCoroutineScopeProvider = DoubleCheck.provider(CoroutineScopesModule_ProvidesCoroutineScopeFactory.create());
      this.terminalScreenPresenterProvider = TerminalScreenPresenter_Factory.create(provideOdomRepositoryProvider, provideTripRepositoryProvider, providesSessionManagerProvider, providesCoroutineScopeProvider, contextProvider);
      this.factoryProvider = TerminalScreenPresenter_Factory_Impl.create(terminalScreenPresenterProvider);
      this.terminalScreenPresenterFactoryProvider = TerminalScreenPresenterFactory_Factory.create(factoryProvider);
      this.viewTripsScreenPresenterProvider = ViewTripsScreenPresenter_Factory.create(provideTripRepositoryProvider, providesSessionManagerProvider, providesCoroutineScopeProvider);
      this.factoryProvider2 = ViewTripsScreenPresenter_Factory_Impl.create(viewTripsScreenPresenterProvider);
      this.viewTripsScreenPresenterFactoryProvider = ViewTripsScreenPresenterFactory_Factory.create(factoryProvider2);
      this.setOfPresenterFactoryProvider = SetFactory.<com.slack.circuit.runtime.presenter.Presenter.Factory>builder(2, 0).addProvider(((Provider) terminalScreenPresenterFactoryProvider)).addProvider(((Provider) viewTripsScreenPresenterFactoryProvider)).build();
      this.setOfUiFactoryProvider = SetFactory.<com.slack.circuit.runtime.ui.Ui.Factory>builder(2, 0).addProvider(((Provider) TerminalScreenUiFactory_Factory.create())).addProvider(((Provider) ViewTripsScreenUIFactory_Factory.create())).build();
      this.provideCircuitProvider = CircuitModule_Companion_ProvideCircuitFactory.create(setOfPresenterFactoryProvider, setOfUiFactoryProvider);
      this.mainActivityProvider = MainActivity_Factory.create(provideCircuitProvider);
    }

    @Override
    public Map<Class<? extends Activity>, Provider<Activity>> getActivityProviders() {
      return Collections.<Class<? extends Activity>, Provider<Activity>>singletonMap(MainActivity.class, ((Provider) mainActivityProvider));
    }
  }
}

[ZacSweers]

It's hard to speculate without details about your build setup, minification, etc. A repro case would be better. Also converted this to a discussion as this is the better place for this.

[see-mack]

👍 It's all on a private repo right now but I'll look at setting something shareable up

[see-mack]

🙌 Figured it out. I needed to add a "release" version of the workaround you'd posted for this issue

val kspReleaseTask = tasks.named<KspTaskJvm>("kspReleaseKotlin")
    tasks.named<KotlinCompile>("kaptGenerateStubsReleaseKotlin").configure {
        source(kspReleaseTask.flatMap { it.destination })
    }