Streamline Dagger Initization.

    @Override

    protected SystemUIRootComponent buildSystemUIRootComponent(Context context) {

        return DaggerCarSystemUIRootComponent.builder()

                .contextHolder(new ContextHolder(context))

                .context(context)

                .build();

    }

                DependencyBinder.class,

                PipModule.class,

                OneHandedModule.class,

                SystemUIFactory.ContextHolder.class,

                SystemServicesModule.class,

                SystemUIModule.class,

                CarSystemUIModule.class,

                CarSystemUIBinder.class

        })

public interface CarSystemUIRootComponent extends SystemUIRootComponent {

    /**

     * Builder for a CarSystemUIRootComponent.

     */

    @Component.Builder

    interface Builder extends SystemUIRootComponent.Builder {

        CarSystemUIRootComponent build();

    }

}

The root component is composed of root modules, which in turn provide the global singleton 

dependencies across all of SystemUI.

- `ContextHolder` is just a wrapper that provides a context.

- `SystemUIFactory` `@Provides` dependencies that need to be overridden by SystemUI

variants (like other form factors e.g. Car). 

### Adding injection to a new SystemUI object

Anything that depends on any `@Singleton` provider from SystemUIRootComponent

should be declared as a `@Subcomponent` of the root component. This requires

declaring your own interface for generating your own modules or just the

object you need injected. The subcomponent also needs to be added to

SystemUIRootComponent in SystemUIFactory so it can be acquired.

```java

public interface SystemUIRootComponent {

+    @Singleton

+    Dependency.DependencyInjector createDependency();

}

public class Dependency extends SystemUI {

  //...

+  @Subcomponent

+  public interface DependencyInjector {

+      Dependency createSystemUI();

+  }

}

```

For objects which extend SystemUI and require injection, you can define an

injector that creates the injected object for you. This other class should

be referenced in [@string/config_systemUIServiceComponents](packages/SystemUI/res/values/config.xml).

```java

public static class DependencyCreator implements Injector {

    @Override

    public SystemUI apply(Context context) {

        return SystemUIFactory.getInstance().getRootComponent()

                .createDependency()

                .createSystemUI();

    }

}

```

SystemUI object are made injectable by adding an entry in `SystemUIBinder`. SystemUIApplication uses

information in that file to locate and construct an instance of the requested SystemUI class.

### Adding a new injectable object

```java

public interface FragmentCreator {

+   NavigationBarFragment createNavigationBar();

    NavigationBarFragment createNavigationBar();

}

```

### Using injection with Views

Generally, you shouldn't need to inject for a view, as the view should

be relatively self contained and logic that requires injection should be

moved to a higher level construct such as a Fragment or a top-level SystemUI

component, see above for how to do injection for both of which.

DO NOT ADD NEW VIEW INJECTION. VIEW INJECTION IS BEING ACTIVELY DEPRECATED.

Still here? Yeah, ok, sysui has a lot of pre-existing views that contain a

lot of code that could benefit from injection and will need to be migrated

off from Dependency#get uses. Similar to how fragments are injected, the view

needs to be added to the interface

com.android.systemui.util.InjectionInflationController$ViewInstanceCreator.

Needing to inject objects into your View's constructor generally implies you

are doing more work in your presentation layer than is advisable.

Instead, create an injected controller for you view, inject into the

controller, and then attach the view to the controller after inflation.

```java

public interface ViewInstanceCreator {

+   QuickStatusBarHeader createQsHeader();

}

```

Presumably you need to inflate that view from XML (otherwise why do you

need anything special? see earlier sections about generic injection). To obtain

an inflater that supports injected objects, call InjectionInflationController#injectable,

which will wrap the inflater it is passed in one that can create injected

objects when needed.

```java

@Override

public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,

        Bundle savedInstanceState) {

    return mInjectionInflater.injectable(inflater).inflate(R.layout.my_layout, container, false);

}

```

There is one other important thing to note about injecting with views. SysUI

already has a Context in its global dagger component, so if you simply inject

a Context, you will not get the one that the view should have with proper

theming. Because of this, always ensure to tag views that have @Inject with

the @Named view context.

```java

public CustomView(@Named(VIEW_CONTEXT) Context themedViewContext, AttributeSet attrs,

        OtherCustomDependency something) {

    //...

}

```

View injection generally causes headaches while testing, as inflating a view

(which may in turn inflate other views) implicitly causes a Dagger graph to 

be stood up, which may or may not contain the appropriately 

faked/mocked/stubbed objects. It is a hard to control process.

## Updating Dagger2

import javax.inject.Inject;

import javax.inject.Named;

import javax.inject.Singleton;

import dagger.Lazy;

import dagger.Subcomponent;

/**

 * Class to handle ugly dependencies throughout sysui until we determine the

 * they have no clients they should not have any registered resources like bound

 * services, registered receivers, etc.

 */

@Singleton

public class Dependency {

    /**

     * Key for getting a the main looper.

        mProviders.put(RecordingController.class, mRecordingController::get);

        mProviders.put(Divider.class, mDivider::get);

        sDependency = this;

        Dependency.setInstance(this);

    }

    @VisibleForTesting

    public static void setInstance(Dependency dependency) {

        sDependency = dependency;

    }

    protected final <T> T getDependency(Class<T> cls) {

    }

    @VisibleForTesting

    protected <T> T createDependency(Object cls) {

    public <T> T createDependency(Object cls) {

        Preconditions.checkArgument(cls instanceof DependencyKey<?> || cls instanceof Class<?>);

        @SuppressWarnings("unchecked")

            return mDisplayName;

        }

    }

    @Subcomponent

    public interface DependencyInjector {

        void createSystemUI(Dependency dependency);

    }

}

package com.android.systemui;

import android.annotation.NonNull;

import android.content.Context;

import android.content.res.Resources;

import android.os.Handler;

import com.android.keyguard.ViewMediatorCallback;

import com.android.systemui.bubbles.BubbleController;

import com.android.systemui.dagger.DaggerSystemUIRootComponent;

import com.android.systemui.dagger.DependencyProvider;

import com.android.systemui.dagger.SystemUIRootComponent;

import com.android.systemui.keyguard.DismissCallbackRegistry;

import com.android.systemui.plugins.FalsingManager;

import java.util.concurrent.Executor;

import dagger.Module;

import dagger.Provides;

/**

 * Class factory to provide customizable SystemUI components.

 */

        // Every other part of our codebase currently relies on Dependency, so we

        // really need to ensure the Dependency gets initialized early on.

        Dependency dependency = new Dependency();

        mRootComponent.createDependency().createSystemUI(dependency);

        Dependency dependency = mRootComponent.createDependency();

        dependency.start();

    }

    protected void initWithRootComponent(@NonNull SystemUIRootComponent rootComponent) {

        if (mRootComponent != null) {

            throw new RuntimeException("Root component can be set only once.");

        }

        mRootComponent = rootComponent;

    }

    protected SystemUIRootComponent buildSystemUIRootComponent(Context context) {

        return DaggerSystemUIRootComponent.builder()

                .dependencyProvider(new DependencyProvider())

                .contextHolder(new ContextHolder(context))

                .context(context)

                .build();

    }

                Dependency.get(DozeParameters.class),

                Dependency.get(BubbleController.class));

    }

    @Module

    public static class ContextHolder {

        private Context mContext;

        public ContextHolder(Context context) {

            mContext = context;

        }

        @Provides

        public Context provideContext() {

            return mContext;

        }

    }

}