Tutorial

    @OnClick(R.id.event_send_localy)
    public void sendLocaly() {
        eventBusManager.send(tvMessage.getText().toString()); // send a string object with no tag
    }
    // generate a $CURRENT_CLASS$ReceiversProvider that refer this method
    // a Pandroid lifecycle delegate will register this generate class to the event bus for you
    // in non PandroidLifecycle class you will have to un/register the provider by yourself
    @EventReceiver
    public void receiveLocalMessage(String message) {
        toastManager.makeToast(getActivity(), message, null);
    }

    @OnClick(R.id.event_send_to)
    public void sendToSecondFragment() {
        eventBusManager.send(tvMessage.getText().toString(), EventSecondFragment.TAG, EventBusManager.DeliveryPolicy.AT_LEAST_ONE);
    }

    @EventReceiver({TAG, "toto"}) //Generate provider with a tag to filter event
    public void onReceiveMessage(@EventTag String tag, String msg) { // '@EventTag String tag' parameter is optional
        String txt = tvMessage.getText().toString();
        String text = txt + "\n" + msg;
        logWrapper.d(TAG, "message with tag '"+tag+"' received : " + msg);
        tvMessage.setText(text);
    }

    enum DeliveryPolicy {
        //The message will be delivery only to the registered receiver at the moment the message is send
        UNCHECKED,
        //The message will be keep until at least one receiver get it
        AT_LEAST_ONE,
        //The message will be keep until another message with the same id override it or it is cancelled
        UNLIMITED
    }

pandroid{
    library('libName') { //Regex matching declared configurator that will bring the dependency
        libParam1 'param1'
        libParam2 'param2'
    }
}

pandroid{
    configurators{
        'name.of.my.lib' {
            gradle {
            //This part will be applyed on your build.gradle
                config ->
                dependencies {
                   compile ('name.of.my.lib:version')
                }
            manifest {
            //This part will be merged to your manifest
                config ->
                        '''
        <application>
            <meta-data
                android:name="my.lib.ApiKey"
                android:value="''' + config.libParam1 + '''" />
        </application>
    '''
    }
}

    @Override
    protected BaseComponent createBaseComponent() {
        return DaggerDemoComponent.builder()
                .demoModule(new DemoModule())
                .pandroidModule(new PandroidModule(this) {
                    @Override
                    protected List<TrustManager> getTrustManagers() {
                        List<TrustManager> keyManagers = super.getTrustManagers();
                        PandroidX509TrustManager trustManager = new PandroidX509TrustManager(DemoApplication.this);
                        trustManager.addCertificate("leroymerlin.com", R.raw.lmfr_cert);// add certificate for your application
                        keyManagers.add(trustManager);
                        return keyManagers;
                    }

                    @Override
                    protected List<KeyManager> getKeyManagers() {
                        return super.getKeyManagers(); // here you can add you own key manager
                    }
                })
                .build();
    }

    //@Inject
    //AnyThingInBaseComponent instance;
    @CallSuper
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        //override layout inflater factory if a custom factory is set
        PandroidViewFactory.installPandroidViewFactory(this);
        super.onCreate(savedInstanceState);
        //initialize PandroidDelegate with the default from PandroidApplication
        BaseComponent baseComponent = PandroidApplication.getInjector(this).getBaseComponent();
        logWrapper = baseComponent.logWrapper();
        eventBusManager = baseComponent.eventBusManager();
        pandroidDelegate = createDelegate();
        pandroidDelegate.onInit(this);
        opener = ActivityOpener.getOpener(this);
    }

    /**
     * call at the end of onResume process. This method will help you determine the king of resume
     * your activity is facing
     *
     * @param state current resume stat of the activity
     */
    protected void onResume(ResumeState state) {
        logWrapper.i(getClass().getSimpleName(), "resume state: " + state);
    }

    @Override
    public void onBackPressed() {
        Fragment fragment = getCurrentFragment(); //override this methode to give your current fragment
        if (fragment != null && fragment instanceof OnBackListener && ((OnBackListener) fragment).onBackPressed()) {
            //back handle by current fragment
        } else if (getSupportFragmentManager().getBackStackEntryCount() > 0) {
            //back handle by getFragmentManager
            getSupportFragmentManager().popBackStack();
        } else {
            onBackExit();
        }
    }


    /**
     * Override this method to show an exit message and enable back confirmation to exit
     *
     * @return true to stop the app exit, false otherwise
     */
    protected boolean showExitMessage() {
        return false;
    }

    /**
     * Override this method to automatically (un)register receiver to the event bus with the activity life cycle
     *
     * @return list of receivers attached by EventBusLifecycleDelegate
     */
    @Override
    public List<EventBusManager.EventBusReceiver> getReceivers() {
        if (getApplication() instanceof ReceiversProvider)
            return ((ReceiversProvider) getApplication()).getReceivers();
        return new ArrayList<>();
    }

public class IcepickLifecycleDelegate extends SimpleLifecycleDelegate<Object> {

    @Override
    public void onCreateView(Object target, View view, Bundle savedInstanceState) {
        super.onCreateView(target, view, savedInstanceState);
        Icepick.restoreInstanceState(target, savedInstanceState);
    }

    @Override
    public void onSaveView(Object target, Bundle outState) {
        if (viewExist)
            Icepick.saveInstanceState(target, outState);
    }
}

    /**
     * initialize LifecycleDelegate that will listen the activity life cycle
     * Override this method to disable or add more delegate
     *
     * @return PandroidDelegate that will be used in pandroid activity / pandroid fragment
     */
    protected PandroidDelegate createBasePandroidDelegate() {
        PandroidDelegate pandroidDelegate = new PandroidDelegate();
        pandroidDelegate.addLifecycleDelegate(new DaggerLifecycleDelegate());
        pandroidDelegate.addLifecycleDelegate(new EventBusLifecycleDelegate(eventBusManager));
        pandroidDelegate.addLifecycleDelegate(new AutoBinderLifecycleDelegate());
        if (PandroidConfig.isLibraryEnable("butterknife")) {
            pandroidDelegate.addLifecycleDelegate(new ButterKnifeLifecycleDelegate());
        } else {
            logWrapper.v(TAG, "ButterKnife is disabled, add the library in Pandroid extension to use it");
        }
        if (PandroidConfig.isLibraryEnable("icepick")) {
            pandroidDelegate.addLifecycleDelegate(new IcepickLifecycleDelegate());
        } else {
            logWrapper.v(TAG, "Icepick is disabled, add the library in Pandroid extension to use it");
        }
        if (PandroidConfig.isLibraryEnable("rxandroid")) {
            pandroidDelegate.addLifecycleDelegate(new RxLifecycleDelegate());
        } else {
            logWrapper.v(TAG, "RxAndroid is disabled, add the library in Pandroid extension to use it");
        }
        return pandroidDelegate;
    }

    @Override
    public PandroidDelegate getPandroidDelegate() {
        return createBasePandroidDelegate();
    }

public class PresenterFragment extends PandroidFragment<FragmentOpener> implements TestPresenter.TestPresenterView{


    @BindLifeCycleDelegate
    LoggerLifeCycleDelegate mLoggerLifeCycleDelegate = new LoggerLifeCycleDelegate();

    @Inject
    @BindLifeCycleDelegate
    TestPresenter mTestPresenter;

    protected void initializeLogger() {
        logWrapper = PandroidLogger.getInstance();
        logWrapper.setDebug(PandroidConfig.DEBUG);
        logWrapper.addLogger(LogcatLogger.getInstance());
        if (PandroidConfig.isLibraryEnable("crashlytics")) {
            logWrapper.addLogger(new CrashlyticsLogger(this));
        }
    }

pandroid
{
    dependencies{
        library "rxandroid"
    }
}

        //We can cast to RxPandroidCall if rxandroid is enable in the plugin configuration
        reviewService.getReview("1")
                .rxEnqueue()
                //bind observer on lifecycle thanks to RxPandroidFragment
                .compose(this.<Review>bindLifecycle())
                .subscribe(o -> {
                    //we can access getActivity() with no check because call will be cancel if our app is paused
                    toastManager.makeToast(getActivity(), o.getTitle(), null);
                }, throwable -> {
                    logWrapper.w(TAG, throwable);
                });

@Target({ElementType.METHOD, ElementType.TYPE})
public @interface RxWrapper {
    /**
     * if true the wrapper will return a single result and complete, otherwise it will return values until it is explicitly cancelled
     *
     * @return true by default
     */
    boolean singleValue() default true;

    /**
     * if true the result will be wrap in a model (use to get multiple error or null response)
     * if the result is wrap no error will be throw to the single
     *
     * @return false by default
     */
    boolean wrapResult() default false;
}

//ReviewManager.java
public interface ReviewManager {
    @RxWrapper
    void getReview(String productId, ActionDelegate<Review> delegate);

    @RxWrapper(wrapResult = true)
    Review getLastReview();
}

//DemoModule.java
    @Provides
    @Singleton
    RxReviewManager provideRxReviewManager(ReviewManager reviewManager) {
        return new RxReviewManager(reviewManager);
    }

//RxFragment.java
public class RxFragment extends RxPandroidFragment<FragmentOpener> {
    private static final String TAG = "RxFragment";
    @Inject
    RxReviewManager reviewManager;

    @Override
    public void onResume() {
        super.onResume();

        reviewManager.rxGetLastReview()
                .flatMap(reviewResult -> reviewResult.result != null ? Single.just(reviewResult.result) : reviewManager.rxGetReview("1"))
                .compose(this.<Review>bindLifecycleObserveOnMain())
                .subscribe(review -> {
                    //we are sure fragment is still not detached thanks to the compose
                    //no need to check getActivity()!=null
                    toastManager.makeToast(getActivity(), review.getTitle(), null);
                }, throwable -> {
                    logWrapper.w(TAG, throwable);
                });

android {

    lintOptions {
        disable 'InvalidPackage'
    }

    buildTypes {
        all {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'build/pandroid/pandroid-proguard-rules.pro'
            if (file('proguard-rules.pro').exists()) {
                proguardFiles 'proguard-rules.pro'
            }
        }
        if (!plugins.hasPlugin("com.android.library")) {
            release {
                minifyEnabled true
            }
        }
    }

}

pandroid{
    secureConfigFields{
        all{
            secureField "YOUR_KEY_NAME", "YOUR_KEY"
        }
        //apply on applicationVariant that contrains the name
        prod { //proDebug prodRelease
            secureField "YOUR_KEY_NAME", "YOUR_PROD_KEY"
        }
    }
}

//your secure field will be add to BuildConfig with the prefix SECURE_
String decryptKey = PandroidConfig.getSecureField(context, BuildConfig.SECURE_YOUR_KEY_NAME)
//...

                    @Override
                    protected List<TrustManager> getTrustManagers() {
                        List<TrustManager> keyManagers = super.getTrustManagers();
                        PandroidX509TrustManager trustManager = new PandroidX509TrustManager(DemoApplication.this);
                        trustManager.addCertificate("leroymerlin.com", R.raw.lmfr_cert);// add certificate for your application
                        keyManagers.add(trustManager);
                        return keyManagers;
                    }

                    @Override
                    protected List<KeyManager> getKeyManagers() {
                        return super.getKeyManagers(); // here you can add you own key manager
                    }

package com.leroymerlin.pandroid.future;

public interface ActionDelegate<T> {

    void onSuccess(T result);

    void onError(Exception e);

}

        //If the CancellableActionDelegate/NetActionDelegate is cancelled the retrofit request will be cancelled too and the result ignored
        //Note that the Delegate is register to the Fragment and will be cancel by the PandroidDelegate for you if the fragment is paused
        reviewManager.getReview("1", new NetActionDelegate<Review>(this) {
            @Override
            public void success(Review result) {
                toastManager.makeToast(getActivity(), result.getTitle(), null);
            }

            @Override
            public void onNetworkError(int statusCode, String errorMessage, String body, Exception e) {
                toastManager.makeToast(getActivity(), errorMessage, null, R.style.Toast_Error);
            }
        });

    @Provides
    @Singleton
    ReviewService provideDemoService(OkHttpClient.Builder clientBuilder, Context context, LogWrapper logWrapper) {
        //PandroidCall handle Action Delegate on main thread and mock annotation
        PandroidCallAdapterFactory factory = PandroidCallAdapterFactory.create(context, logWrapper);
        factory.setMockEnable(PandroidConfig.DEBUG);
        Retrofit.Builder builder = new Retrofit.Builder()
                .client(clientBuilder.build())
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(factory)
                .baseUrl(BuildConfig.BASE_URL_PRODUCT);
        return builder.build().create(ReviewService.class);
    }

    @Override
    public void getReview(String productId, final ActionDelegate<Review> delegate) {

        //Standard Retrofit way
        /*
        Call<Review> review = reviewService.getReview(productId);
        review.enqueue(new Callback<Review>() {

            @Override
            public void onResponse(Call<Review> call, Response<Review> response) {
                try {
                    if (response.isSuccessful()) {
                        delegate.onSuccess(response.body());
                    } else {
                        String string = response.errorBody().string();
                        delegate.onError(new Exception(response.code() + ": " + string));
                    }
                } catch (IOException e) {
                    onFailure(call, e);
                }
            }

            @Override
            public void onFailure(Call<Review> call, Throwable t) {
                //Be carefull with the onFailure. This method can be called by retrofit outside of the main thread
                //You can't update you UI directly
                //delegate.onError(new Exception("Fail to get product", t)); => Error
            }
        });
        */

        // Pandroid way

        // if you need the Retrofit Response object
        PandroidCall<Response<Review>> reviewReponsePandroidWay = reviewService.getReviewReponsePandroidWay(productId);
        reviewReponsePandroidWay.enqueue(new ActionDelegate<Response<Review>>() {

            @Override
            public void onSuccess(Response<Review> result) {
                lastResult = result.body();
                //be careful the response could be an error code
                //you have to check it yourself
                if (result.isSuccessful()){
                    logWrapper.d(TAG, "result received has retrofit Response");
                }
            }

            @Override
            public void onError(Exception e) {
                logWrapper.e(TAG, e);
            }
        });

        //Easiest way to get your object
        //if the retrofit response is an error it will pass the onError method of the delegate
        PandroidCall<Review> reviewPandroidWay = reviewService.getReviewPandroidWay(productId);
        reviewPandroidWay.enqueue(delegate);
    }

    enum DeliveryPolicy {
        //The message will be delivery only to the registered receiver at the moment the message is send
        UNCHECKED,
        //The message will be keep until at least one receiver get it
        AT_LEAST_ONE,
        //The message will be keep until another message with the same id override it or it is cancelled
        UNLIMITED
    }

        final RecyclerViewAdapter<String> adapter = new RecyclerViewAdapter<String>(new RecyclerFactory<RecyclerHolder<String>>() {
            @Override
            public RecyclerHolder<String> create(LayoutInflater inflater, ViewGroup parent, int viewType) {
                //override the adapter getItemType to handle different type of cell
                //here you can return the holder dealing with the object and type you have
                return new RecyclerHolder<String>(inflater.inflate(R.layout.cell_list, parent, false)) {

                    public TextView tvContent;

                    @Override
                    protected void bindView(View view) {
                        super.bindView(view);
                        tvContent = (TextView) view;
                    }

                    @Override
                    public void setContent(String content, int index) {
                        tvContent.setText(content);
                    }
                };
            }
        }
        );

        //this Touch Helper handle swipe to remove gesture and change position
        SimpleItemTouchHelperCallback simpleItemTouchHelperCallback = new SimpleItemTouchHelperCallback(adapter) {
            @Override
            public void onSwiped(RecyclerView.ViewHolder viewHolder, int direction) {
                toastManager.makeToast(getActivity(), "Item " + viewHolder.getAdapterPosition() + " removed", null, R.style.Toast_Warm);
                super.onSwiped(viewHolder, direction);
            }
        };
        ItemTouchHelper touchHelper = new ItemTouchHelper(simpleItemTouchHelperCallback);
        touchHelper.attachToRecyclerView(rvMenu);
        adapter.addAll(getData());

        //you can add item click listener and long click listener on you adapter
        adapter.setOnItemClickListener(new RecyclerViewAdapter.OnItemClickListener<String>() {
            @Override
            public void onItemClick(RecyclerViewAdapter<String> parent, View view, int position, long id) {
                toastManager.makeToast(getActivity(), "Button " + position + " clicked", null, R.style.Toast, getResources().getInteger(R.integer.toast_short_duration));
            }
        });
        rvMenu.setAdapter(adapter);

        adapter = new PandroidAdapter<>();
        adapter.registerFactory(0, HolderFactory.<String>create(R.layout.cell_list, (cellView, data, index) -> ((TextView) cellView).setText(data)));
        adapter.addAll(getData());
        adapter.setOnItemClickListener((parent, itemView, position, id) -> {
            changeData(position);
        });
        rvMenu.setAdapter(adapter);

        adapter<String> {
            holder {
                layout = R.layout.cell_list
                itemType = 0 //your can use class has type, hashcode will be used
                binder = { view, data, index -> (view as Button).text = data }
            }
            holder {
                layout = R.layout.cell_list
                itemType = 1
                holderClass = CustomTxtHolder::class
            }
            holder {
                itemType = 2
                factory = CustomHolderFactory()
            }
            itemTypes { adapter: PandroidAdapter<String>, item: String, position: Int -> position % 3 }
        }

    <com.leroymerlin.pandroid.ui.list.QuickHeaderLayout
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1">
        <!-- The first view is the scrollable one -->
        <ListView
            android:id="@+id/list_lv"
            android:padding="@dimen/small_spacing"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />
        <!-- The second layout is the view you want to use as a header -->
        <TextView
            android:layout_width="match_parent"
            android:layout_height="50dp"
            android:background="@color/pandroid_gray"
            android:gravity="center"
            android:text="@string/list_header_listview" />
    </com.leroymerlin.pandroid.ui.list.QuickHeaderLayout>

    <declare-styleable name="ToastAppearance">
        <attr name="toastTextColor" format="color" />
        <attr name="toastButtonTextColor" format="color" />
        <attr name="toastBackground" format="color" />
    </declare-styleable>

    <style name="Toast">
        <item name="toastTextColor">@color/white</item>
        <item name="toastButtonTextColor">@color/white</item>
        <item name="toastBackground">@color/pandroid_green</item>
    </style>

    <style name="Toast.Error">
        <item name="toastBackground">@color/pandroid_red</item>

    </style>

    <style name="Toast.Warm">
        <item name="toastBackground">@color/pandroid_orange</item>
    </style>

pandroid {
    enableViewSupport = true
}

        <!-- if pandroid{ enableViewSupport = true } Button will be replace by Pandroid support view-->
        <Button
            tools:ignore="MissingPrefix"
            android:id="@+id/animation_btn_material"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@string/animation_open_material"
            app:drawableLeftPCompat="@drawable/ic_error_outline_24dp"
            app:drawableRightPCompat="@drawable/ic_error_outline_24dp"
            app:drawableTopPCompat="@drawable/ic_error_outline_24dp"
            app:drawableBottomPCompat="@drawable/ic_error_outline_24dp"
            app:drawableTintPCompat="@color/pandroid_green"
             />

        <!-- if pandroid{ enableViewSupport = false } you can use Pandroid support view-->
        <com.leroymerlin.pandroid.ui.support.PandroidCompatButton
            tools:ignore="MissingPrefix"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@string/animation_open_material"
            app:drawableLeftPCompat="@drawable/ic_error_outline_24dp"
            app:drawableRightPCompat="@drawable/ic_error_outline_24dp"
            app:drawableTopPCompat="@drawable/ic_error_outline_24dp"
            app:drawableBottomPCompat="@drawable/ic_error_outline_24dp"
            app:drawableTintPCompat="@color/pandroid_green"
            android:visibility="gone"
            tools:visibility="visible"
            />

        Bundle b = new Bundle();
        b.putLong("fibonacci", 28);
        getLoaderManager().initLoader(0, b, new LoaderManager.LoaderCallbacks<Long>() {
            @Override
            public Loader<Long> onCreateLoader(int id, Bundle args) {
                final long fibonacci = args.getLong("fibonacci");
                return new SimpleAsyncTaskLoader<Long>(getActivity()) {
                    @Override
                    public Long loadInBackground() {
                        return fibonacci(fibonacci);
                    }
                };
            }

            @Override
            public void onLoadFinished(Loader<Long> loader, Long data) {
                toastManager.makeToast(getActivity(), "Result : " + data, null);
            }

            @Override
            public void onLoaderReset(Loader<Long> loader) {

            }
        });

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.google.gms:google-services:3.2.0'
    }
}
//apply the plugin at the end of your build.gradle to avoid error
apply plugin 'com.google.gms.google-services'

pandroid {
    dependencies {
        library 'play-services-analytics'
    }
}

    @Provides
    @Singleton
    AnalyticsManager provideAnalyticsManager(GoogleAnalyticsManager googleAnalyticsManager) {

        // set your GA ID Analytics
        String AnalyticsGaId = "YOUR_ANALYTICS_GA_ID";

        if (!TextUtils.isEmpty(AnalyticsGaId)) {
            Tracker tracker = googleAnalyticsManager.getAnalytics().newTracker(AnalyticsGaId);
            tracker.enableAutoActivityTracking(true);
            googleAnalyticsManager.getTrackers().add(tracker);
        }
        return googleAnalyticsManager;
    }

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.google.gms:google-services:3.2.0'
    }
}
//apply the plugin at the end of your build.gradle to avoid error
apply plugin 'com.google.gms.google-services'

pandroid {
    dependencies {
        library 'firebase-analytics'
    }
}