使用RxJava和改型[Android]的空对象引用

我正在构建一个简单的android应用程序，当我试图将数据发送到API时，出现了这个错误。我使用RxJava和改型，我使用模型视图演示器

我得到这个错误“BTN服务是一个空对象引用” 我总是得到BTN服务null，请帮助解决这个问题。 多谢各位

这就是JSON

request:
    {
     name: '',
     mobile: '',
     email: ''
    }

这是我的卑鄙行为

public abstract class BaseActivity extends AppCompatActivity {

    @BindString(R.string.loading)
    public String loading;
    @BindInt(R.integer.success_code)
    public int successCode;
    @BindInt(R.integer.success_activication_code)
    public  int activicationSuccessCode;


    protected BTNService btnService;
    protected abstract int getLayout();
    private ProgressDialog progressDialog;
    private CompositeSubscription subscriptions;
    protected RxBus bus;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(getLayout());
        Icepick.restoreInstanceState(this, savedInstanceState);
        ButterKnife.bind(this);
        this.progressDialog = new ProgressDialog(this);
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        Icepick.saveInstanceState(this, outState);
    }


    @Override
    protected void onStart() {
        super.onStart();
        this.subscriptions = new CompositeSubscription();
    }


    @Override
    public void onStop() {
        super.onStop();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        this.progressDialog.dismiss();
    }

    public BTNService getBTNService() {
        return btnService;
    }

    public RxBus getBus() {
        return bus;
    }

    public void showProgressDialog(String message) {
        if (progressDialog != null) {
            progressDialog.setMessage(message);
            progressDialog.show();
        }
    }

    public void dismissProgressDialog() {
        progressDialog.hide();
    }

    public boolean isFragmentNotNull(String tag) {
        if (getSupportFragmentManager().findFragmentByTag(tag) != null) {
            return true;
        } else {
            return false;
        }
    }

    public boolean isFragmentVisible(String tag) {
        if (isFragmentNotNull(tag)
                && getSupportFragmentManager().findFragmentByTag(tag).isVisible()) {
            return true;
        } else {
            return false;
        }
    }

}

这是我的基本片段

public abstract class BaseFragment extends Fragment implements Validator.ValidationListener {

    @BindString(R.string.loading)
    public String loading;
    @BindInt(R.integer.success_code)
    public int successCode;
    @BindInt(R.integer.success_activication_code)
    public  int activicationSuccessCode;
    @BindString(R.string.connection_error)
    public String connectionError;

    protected abstract int getLayout();
    protected Validator validator;
    private CompositeSubscription subscriptions;
    protected RxBus bus;


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

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        this.bus = ((BaseActivity) getActivity()).getBus();
    }

    @Override
    public void onStart() {
        super.onStart();
        this.subscriptions = new CompositeSubscription();
/*        this.subscriptions
                .add(bus.toObserverable()
                        .subscribe(new Action1<Object>() {
                            @Override
                            public void call(Object event) {
                                if (event instanceof RxBusObject) {
                                    RxBusObject busObject = (RxBusObject) event;
                                    busHandler();
                                }
                            }
                        })
                );*/
    }

    @Override
    public void onStop() {
        super.onStop();
        this.subscriptions.clear();
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(getLayout(), container, false);
        ButterKnife.bind(this, view);
        return view;
    }

    public RxBus getBus() {
        return this.bus;
    }

    @Override
    public void onValidationSucceeded() {

    }

    @Override
    public void onValidationFailed(List<ValidationError> errors) {
        for (ValidationError error : errors) {
            View view = error.getView();
            String message = error.getCollatedErrorMessage(getActivity());
            if (view instanceof EditText) {
                EditText et = ((EditText) view);
                et.setError(message);
                et.requestFocus();
            } else {
                Toast.makeText(getActivity(), message, Toast.LENGTH_LONG).show();
            }
        }
    }



    public void showSuccessDialog(String message, final Boolean isFinishActivity) {
        new MaterialDialog.Builder(getActivity())
                .iconRes(R.mipmap.ic_launcher)
                .title(getString(R.string.success).toUpperCase())
                .titleColor(Color.WHITE)
                .content(message)
                .contentColor(Color.WHITE)
                .positiveText(R.string.ok)
                .positiveColor(Color.WHITE)
                .onPositive(new MaterialDialog.SingleButtonCallback() {
                    @Override
                    public void onClick(MaterialDialog dialog, DialogAction which) {
                        if (isFinishActivity) {
                            getActivity().finish();
                        }
                    }
                })
                .cancelable(false)
                .show();
    }



    public void showProgressDialog(String message) {
        ((BaseActivity) getActivity()).showProgressDialog(message);
    }



    public Validator getValidator() {
        return validator;
    }

    public BTNService.Api getApi() {
        return ((BaseActivity) getActivity()).getBTNService().getApi();
    }

    public void dismissProgressDialog() {
        ((BaseActivity) getActivity()).dismissProgressDialog();
    }


}

公共抽象类BaseFragment扩展片段实现Validator.ValidationListener{
@BindString（R.string.load）
公共字符串加载；
@BindInt（R.integer.success\u代码）
公共int成功码；
@BindInt（R.integer.success\u activation\u代码）
公共int活动成功代码；
@BindString（R.string.connection\u错误）
公共字符串连接错误；
受保护的抽象int getLayout（）；
受保护的验证器；
私人合成订阅；
受保护的RxBus总线；
@凌驾
创建时的公共void（@Nullable Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
}
@凌驾
ActivityCreated上的公共无效（@Nullable Bundle savedinStateCState）{
super.onActivityCreated（savedInstanceState）；
this.bus=（（BaseActivity）getActivity（））.getBus（）；
}
@凌驾
public void onStart（）{
super.onStart（）；
this.subscriptions=new CompositeSubscription（）；
/*这是订阅
.add（bus.toobserver（））
.订阅（新操作1（）{
@凌驾
公共作废调用（对象事件）{
if（RxBusObject的事件实例）{
RxBusObject总线对象=（RxBusObject）事件；
布山德勒（）；
}
}
})
);*/
}
@凌驾
公共void onStop（）{
super.onStop（）；
this.subscriptions.clear（）；
}
@可空
@凌驾
CreateView上的公共视图（布局、充气机、视图组容器、捆绑包保存状态）{
视图=充气机。充气（getLayout（），容器，false）；
ButterKnife.bind（这个，视图）；
返回视图；
}
公共RxBus getBus（）{
还这辆车；
}
@凌驾
public void onValidationSucceeded（）{
}
@凌驾
public void onValidationFailed（列表错误）{
对于（ValidationError错误：错误）{
视图=错误。getView（）；
字符串消息=错误。GetCollaterRorMessage（getActivity（））；
如果（查看EditText的实例）{
EditText et=（（EditText）视图）；
设置错误（消息）；
et.requestFocus（）；
}否则{
Toast.makeText（getActivity（），message，Toast.LENGTH_LONG）.show（）；
}
}
}
public void showSuccessDialog（字符串消息，最终布尔值为FinishActivity）{
new MaterialDialog.Builder（getActivity（））
.iconRes（R.mipmap.ic_启动器）
.title（getString（R.string.success）.toUpperCase（））
.标题颜色（颜色.白色）
.内容（信息）
.contentColor（颜色.白色）
.positiveText（R.string.ok）
.正色（颜色.白色）
.onPositive（新材料对话框.SingleButtonCallback（）{
@凌驾
public void onClick（MaterialDialog对话框、DialogAction which）{
如果（isFinishActivity）{
getActivity（）.finish（）；
}
}
})
.可取消（错误）
.show（）；
}
公共void showProgressDialog（字符串消息）{
（（BaseActivity）getActivity（））.showProgressDialog（消息）；
}
公共验证器getValidator（）{
返回验证器；
}
公共BTNService.Api getApi（）{
返回（（BaseActivity）getActivity（））.getBTN服务（）.getApi（）；
}
public void dismissProgressDialog（）{
（（BaseActivity）getActivity（））.dismissProgressDialog（）；
}
}

这是我的改装课

public BTNService(Context context) {
        if (retrofit==null) {
        Retrofit retrofit = new Retrofit.Builder()
                .client(provideOkHttpClient(context))
                .baseUrl(BASE_URL)
                .build();
        this.api = retrofit.create(Api.class);
        }
    }

    private OkHttpClient provideOkHttpClient(final Context context) {
        HttpLoggingInterceptor httpLoggingInterceptorinterceptor = new HttpLoggingInterceptor();
        httpLoggingInterceptorinterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
        httpClient.addInterceptor(httpLoggingInterceptorinterceptor);
        httpClient.addInterceptor(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request request = chain.request();
                Response response = chain.proceed(request);
                return response;
            }
        });
        return httpClient.build();
    }

    public Api getApi() {
        return api;
    }

    public interface Api {

   @POST(PORTAL_URL + "customer/register")
   Observable<SignUpResponse> regsiterCustomer(@Path("email") String Email,
                                               @Path("name") String Name,
                                               @Path("mobile") String PhoneNumber);
}

公共BTN服务（上下文）{
如果（改装==null）{
改装改装=新改装.Builder（）
.client（provideOkHttpClient（上下文））
.baseUrl（基本URL）
.build（）；
this.api=reformation.create（api.class）；
}
}
专用OkHttpClient provideOkHttpClient（最终上下文）{
HttpLoggingInterceptor HttpLoggingInterceptor=新的HttpLoggingInterceptor（）；
HttpLoggingInterceptor.setLevel（HttpLoggingInterceptor.Level.BODY）；
OkHttpClient.Builder httpClient=新建OkHttpClient.Builder（）；
httpClient.addInterceptor（HttpLoggingInterceptor）；
httpClient.addInterceptor（新的拦截器（）{
@凌驾
公共响应拦截（链）引发IOException{
Request=chain.Request（）；
响应=链。继续（请求）；
返回响应；
}
});
返回httpClient.build（）；
}
公共Api getApi（）{
返回api；
}
公共接口Api{
@POST（门户网站URL+“客户/注册”）
可观察的regsiterercustomer（@Path（“email”）字符串电子邮件，
@路径（“名称”）字符串名称，
@路径（“移动”）字符串电话号码）；
}

这是我的演讲者

public class SignUpPresenter {

    private SignUpFragment fragment;

    public SignUpPresenter(SignUpFragment fragment) {
        this.fragment = fragment;
    }

    public SignUpRequest constructSignUpRequest() {
        SignUpRequest request = new SignUpRequest();
        request.setName(getAndTrimValueFromEditText(fragment.etName));
        request.setEmail(getAndTrimValueFromEditText(fragment.etEmail));
        request.setMobile(getAndTrimValueFromEditText(fragment.etPhone));
        return request;
    }

    private String getAndTrimValueFromEditText(EditText e) {
        return e.getText().toString().trim();
    }

    void signup (){
        this.register(constructSignUpRequest());
    }

    void register(final SignUpRequest signUpRequest) {
        fragment.showProgressDialog(fragment.loading);
        fragment.getApi().regsiterCustomer(
                signUpRequest.getName(),
                signUpRequest.getEmail(),
                signUpRequest.getMobile())
                .subscribeOn(Schedulers.io())
                .subscribe(new Observer<GenericResponse>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {
                        fragment.dismissProgressDialog();
                        Timber.e(e.getLocalizedMessage());
                        Toast.makeText(fragment.getContext(), fragment.connectionError, Toast.LENGTH_SHORT).show();
                    }

                    @Override
                    public void onNext(GenericResponse genericResponse) {
                        fragment.dismissProgressDialog();
                        Toast.makeText(fragment.getContext(), genericResponse.getInfo(), Toast.LENGTH_SHORT).show();
                        if (genericResponse.getCode() == fragment.successCode) {
                            /*fragment.gotoActivationCodeActivity(SignUpRequest.getEmail(), SignUpRequest.get());*/
                            fragment.gotoQuestionActivity(signUpRequest.getEmail(), signUpRequest.getEmail(), signUpRequest.getMobile());
                        }
                    }
                });
    }

公共类签名者{
私有注册片段；
公共SignUpPresenter（SignUpFragment片段）{
this.fragment=片段；
}
public SignUpRequest构造函数SignUpRequest（）{
注册请求
    public static <T> Function<BaseResponse<T>, Observable<T>> convertDataFlatMap() {
    return new Function<BaseResponse<T>, Observable<T>>() {
        @Override
        public Observable<T> apply(BaseResponse<T> response) {
            if (!Constants.SUCCESS_CODE.equals(response.getStatus_code())) {
                BaseErrorResponse baseErrorResponse = new BaseErrorResponse();
                baseErrorResponse.setError(response.getStatus_code(),
                        response.getStatus());
                return Observable.error(BaseException.toServerError(baseErrorResponse));
            }

            T data = response.getData();
            if (null == data) {
                return Observable.empty();
            }

            return Observable.just(response.getData());
        }
    };
}