Third-party services wrapper, for example social networks authorization

README.md

ThirdPartyServiceManager

Wrapper for social network authorization

Example

        ThirdPartyService googleAuthService = new GoogleAuthService()//your service that excends from ThirdPartyService
                .result(data -> {/* on complete */}, {/* on error */});
        someButton.setOnClickListener(v -> googleAuthService.startLogin());

        ThirdPartyServiceManager serviceManager = ThirdPartyServiceManager.create(/* activity */)
                .with(googleAuthService)
                .build();

CancelFunction.java

public interface CancelFunction<T> {

    void onCancel(T data);
}

ErrorFunction.java

public interface ErrorFunction<T> {

    void onError(T error);
}

ResultCallback.java

public class ResultCallback<SUCCESS, ERROR, CANCEL> {

    private SuccessFunction<SUCCESS> successFunction;
    private CancelFunction<CANCEL> cancelFunction;
    private ErrorFunction<ERROR> errorFunction;

    ResultCallback() {
    }

    void setSuccessFunction(SuccessFunction<SUCCESS> successFunction) {
        this.successFunction = successFunction;
    }

    void setCancelFunction(CancelFunction<CANCEL> cancelFunction) {
        this.cancelFunction = cancelFunction;
    }

    void setErrorFunction(ErrorFunction<ERROR> errorFunction) {
        this.errorFunction = errorFunction;
    }

    public void success(SUCCESS data) {
        if (successFunction != null) {
            successFunction.onSuccess(data);
        }
    }

    public void error(ERROR data) {
        if (errorFunction != null) {
            errorFunction.onError(data);
        }
    }

    public void cancel(CANCEL data) {
        if (cancelFunction != null) {
            cancelFunction.onCancel(data);
        }
    }
}

SuccessFunction.java

public interface SuccessFunction<T> {

    void onSuccess(T data);
}

ThirdPartyService.java

public abstract class ThirdPartyService<SUCCESS, ERROR, CANCEL> {

    private Fragment starterFragment;

    private ResultCallback<SUCCESS, ERROR, CANCEL> resultCallback = new ResultCallback<>();

    final void setStarterFragment(Fragment starterFragment) {
        this.starterFragment = starterFragment;
    }

    public final ThirdPartyService result(SuccessFunction<SUCCESS> successFunction) {
        return result(successFunction, null, null);
    }

    public final ThirdPartyService result(SuccessFunction<SUCCESS> successFunction,
                                          ErrorFunction<ERROR> errorFunction) {
        return result(successFunction, errorFunction, null);
    }

    public final ThirdPartyService result(SuccessFunction<SUCCESS> successFunction,
                                          ErrorFunction<ERROR> errorFunction,
                                          CancelFunction<CANCEL> cancelFunction) {
        resultCallback.setSuccessFunction(successFunction);
        resultCallback.setCancelFunction(cancelFunction);
        resultCallback.setErrorFunction(errorFunction);
        return this;
    }

    public final void startLogin() {
        startActivity(starterFragment);
    }

    protected ResultCallback<SUCCESS, ERROR, CANCEL> getResultCallback() {
        return resultCallback;
    }

    protected void onStart() {

    }

    protected void onStop() {

    }

    protected abstract void init(@NonNull Activity activity);

    protected abstract void startActivity(@NonNull Fragment starterFragment);

    protected abstract boolean handleActivityResult(int requestCode, int resultCode, Intent data);

}

ThirdPartyServiceFragment.java

public class ThirdPartyServiceFragment extends Fragment {

    private List<ThirdPartyService> thirdPartyServices;

    public void setThirdPartyServices(List<ThirdPartyService> thirdPartyServices) {
        this.thirdPartyServices = thirdPartyServices;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        for (ThirdPartyService service : thirdPartyServices) {
            boolean handled = service.handleActivityResult(requestCode, resultCode, data);
            if (handled) {
                return;
            }
        }
    }
}

ThirdPartyServiceManager.java

public class ThirdPartyServiceManager {

    private static final String FRAGMENT_TAG = ThirdPartyServiceManager.class.getCanonicalName();

    private List<ThirdPartyService> services = new LinkedList<>();

    private ThirdPartyServiceFragment fragment;

    public static ThirdPartyServiceManager.Builder create(@NonNull Activity activity) {
        return new Builder(activity);
    }

    private ThirdPartyServiceManager(@NonNull Activity activity, @NonNull List<ThirdPartyService> services) {
        this.services = services;
        fragment = getRetrySignInFragment(activity);
        fragment.setThirdPartyServices(services);
        initServices(activity, fragment);
    }

    public void onStart() {
        for (ThirdPartyService service : services) {
            service.onStart();
        }
    }

    public void onStop() {
        for (ThirdPartyService service : services) {
            service.onStop();
        }
    }

    private ThirdPartyServiceFragment getRetrySignInFragment(Activity activity) {
        ThirdPartyServiceFragment retrySignInFragment = findRemoteServiceFragment(activity);
        if (retrySignInFragment == null) {
            retrySignInFragment = new ThirdPartyServiceFragment();
            FragmentManager fragmentManager = activity.getFragmentManager();
            fragmentManager
                    .beginTransaction()
                    .add(retrySignInFragment, FRAGMENT_TAG)
                    .commitAllowingStateLoss();
            fragmentManager.executePendingTransactions();
        }
        return retrySignInFragment;
    }

    private ThirdPartyServiceFragment findRemoteServiceFragment(Activity activity) {
        return (ThirdPartyServiceFragment) activity.getFragmentManager().findFragmentByTag(FRAGMENT_TAG);
    }

    private void initServices(Activity activity, Fragment starterFragment) {
        for (ThirdPartyService service : services) {
            service.init(activity);
            service.setStarterFragment(starterFragment);
        }
    }

    public static class Builder {

        private Activity activity;
        private List<ThirdPartyService> services = new LinkedList<>();

        private Builder(@NonNull Activity activity) {
            this.activity = activity;
        }

        public Builder with(@NonNull ThirdPartyService service) {
            services.add(service);
            return this;
        }

        public ThirdPartyServiceManager build() {
            return new ThirdPartyServiceManager(activity, services);
        }
    }
}