仅在满足条件的情况下才将信息发送到泛型

Question

The Image shows the dashboard of the application

package com.example.leeyueloong.proximityapplication;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.Toast;

import com.estimote.mustard.rx_goodness.rx_requirements_wizard.Requirement;
import com.estimote.mustard.rx_goodness.rx_requirements_wizard.RequirementsWizardFactory;
import com.estimote.proximity_sdk.proximity.EstimoteCloudCredentials;
import com.estimote.proximity_sdk.proximity.ProximityContext;
import com.estimote.proximity_sdk.proximity.ProximityObserver;
import com.estimote.proximity_sdk.proximity.ProximityObserverBuilder;
import com.estimote.proximity_sdk.proximity.ProximityZone;
import com.ubidots.ApiClient;
import com.ubidots.Variable;

import java.util.ArrayList;
import java.util.List;

import kotlin.Unit;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;

public class MainActivity extends AppCompatActivity {

private ProximityObserver proximityObserver;
private int send;


@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    EstimoteCloudCredentials cloudCredentials =
            new EstimoteCloudCredentials("tan-kok-hui-s-proximity-fo-07q", "d18623351c273ce3e09ffcc1f6201861");
    // 2. Create the Proximity Observer
    this.proximityObserver =
            new ProximityObserverBuilder(getApplicationContext(), cloudCredentials)
                    .withOnErrorAction(new Function1<Throwable, Unit>() {
                        @Override
                        public Unit invoke(Throwable throwable) {
                            Log.e("app", "proximity observer error: " + throwable);
                            return null;
                        }
                    })

                    .withLowLatencyPowerMode()
                    .build();


    // add this below:

    ProximityZone zone = this.proximityObserver.zoneBuilder()

            .forTag("desks")
            .inNearRange()
            .withOnEnterAction(new Function1<ProximityContext, Unit>() {
                @Override
                public Unit invoke(ProximityContext context) {
                    String deskOwner = context.getAttachments().get("desk-owner");
                    Log.d("app", "Welcome to " + deskOwner + "'s desk");
                    return null;
                }
            })
            .withOnExitAction(new Function1<ProximityContext, Unit>() {
                @Override
                public Unit invoke(ProximityContext context) {
                    return null;
                }


            })

            .withOnChangeAction(new Function1<List<? extends ProximityContext>, Unit>() {

                @Override
                public Unit invoke(List<? extends ProximityContext> contexts) {

                    List<String> deskOwners = new ArrayList<>();
                    for (ProximityContext context : contexts) {

                        deskOwners.add(context.getAttachments().get("desk-owner"));
                    }
                    for (int i = 0; i < deskOwners.size(); i++) {

                        if (deskOwners.get(i).contains("Peter")) {
                            send = 1;
                            Toast.makeText(MainActivity.this, "Alert:Unauthorized Zone", Toast.LENGTH_SHORT).show();
                            Toast.makeText(MainActivity.this, "Sending information to ubidots..........", Toast.LENGTH_LONG).show();
                        } else if (deskOwners.get(i).contains("Alex")) {
                            send = 0;
                            Toast.makeText(MainActivity.this, "Device has entered this range", Toast.LENGTH_SHORT).show();

                        }
                        else if (deskOwners.get(i).contains("Paul"))
                        {

                        }
                    }

                    Log.d("app", "In range of desks: " + deskOwners);
                    return null;
                }


            })
            .create();

    this.proximityObserver.addProximityZone(zone);
    ProximityZone innerZone = this.proximityObserver.zoneBuilder()
            .forTag("treasure")
            .inCustomRange(3.0)
            .create();

    ProximityZone outerZone = this.proximityObserver.zoneBuilder()
            .forTag("treasure")
            .inCustomRange(9.0)
            .create();

    RequirementsWizardFactory
            .createEstimoteRequirementsWizard()
            .fulfillRequirements(MainActivity.this,
                    // onRequirementsFulfilled
                    new Function0<Unit>() {
                        @Override
                        public Unit invoke() {
                            Log.d("app", "requirements fulfilled");
                            proximityObserver.start();
                            return null;
                        }
                    },
                    // onRequirementsMissing
                    new Function1<List<? extends Requirement>, Unit>() {
                        @Override
                        public Unit invoke(List<? extends Requirement> requirements) {
                            Log.e("app", "requirements missing: " + requirements);
                            return null;
                        }
                    },
                    // onError
                    new Function1<Throwable, Unit>() {
                        @Override
                        public Unit invoke(Throwable throwable) {
                            Log.e("app", "requirements error: " + throwable);
                            return null;
                        }
                    });
}
private BroadcastReceiver mBatteryReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if (send == 1 || send == 0) {
            new ApiUbidots().execute(send);
        }


    }
};
    @Override
    protected void onStart() {
        super.onStart();
            registerReceiver(mBatteryReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
        }

//停止BroadcastReceiver

    @Override
    protected void onStop() {
        unregisterReceiver(mBatteryReceiver);
        super.onStop();
    }

//负责将变量发送到泛型

    public class ApiUbidots extends AsyncTask<Integer, Void, Void> {
        private final String API_KEY = "A1E-0109ebb46b4990a4ed82f74d2912a9e6b481";
        private final String VARIABLE_ID = "5b62ab7ac03f97418ba1c28e";

        @Override
        protected Void doInBackground(Integer... params) {
            ApiClient apiClient = new ApiClient(API_KEY);
            Variable batteryLevel = apiClient.getVariable(VARIABLE_ID);

            batteryLevel.saveValue(params[0]);
            return null;
        }
    }


}

问题是我能够将数据发送到泛型，但是我想这样做，以便只有在满足条件的情况下，才可以将其发送到云。除此之外，它不会将任何数据发送到云。