隐藏应用程序后如何发送和接收数据？

Question

隐藏或屏幕关闭时，我的应用程序未将JSON字符串发送到PHP脚本。 我使用HttpURLConnection。 我的应用发送GPS位置。 我希望该应用程序可以像Messenger一样在backgoround中运行。 发送和接收数据在AsyncTask中进行。 怎么了？

public class MyAsyncTask extends AsyncTask<JSONObject, Void, JSONObject> {

    String addr = GlobalConfig.addr;
    String prot = GlobalConfig.prot;
    int port = GlobalConfig.port;

    @Override
    protected void onPreExecute() {

    }

    @Override
    protected JSONObject doInBackground(JSONObject... params) {

        JSONObject json = params[0];
        String string = "json="+json;

        try {

            URL url = new URL(prot,addr,port,"json/myLocation.php");

            HttpURLConnection httpCon = (HttpURLConnection) url.openConnection();
            httpCon.setDoOutput(true);
            httpCon.setDoInput(true);
            httpCon.setUseCaches(false);
            httpCon.setConnectTimeout(15000);
            httpCon.setRequestProperty("Content-Length", Integer.toString(string.length()));
            httpCon.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            httpCon.setRequestMethod("POST");

            DataOutputStream wr = new DataOutputStream(httpCon.getOutputStream());
            wr.writeBytes(string);
            wr.flush();
            wr.close();

            int responseCode = httpCon.getResponseCode();

        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;

    }

    @Override
    protected void onPostExecute(JSONObject json) {

    }

}


public class GPSTracker extends Service implements LocationListener {

    private final Context mContext;

    boolean isGPSEnabled = false;

    boolean isNetworkEnabled = false;

    boolean canGetLocation = false;

    Location location;
    double latitude;
    double longitude;

    private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 10;

    private static final long MIN_TIME_BW_UPDATES = 10000;

    protected LocationManager locationManager;

    public GPSTracker(Context context) {
        this.mContext = context;
        getLocation();
    }

    public Location getLocation() {
        try {
            locationManager = (LocationManager) mContext.getSystemService(LOCATION_SERVICE);

            isGPSEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);

            isNetworkEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);

            if (!isGPSEnabled && !isNetworkEnabled) {

            } else {
                this.canGetLocation = true;

                if (isNetworkEnabled) {
                    locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER,
                            MIN_TIME_BW_UPDATES,
                            MIN_DISTANCE_CHANGE_FOR_UPDATES, this);

                    if (locationManager != null) {
                        location = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
                        if (location != null) {
                            latitude = location.getLatitude();
                            longitude = location.getLongitude();
                        }
                    }
                }

                if (isGPSEnabled) {
                    if (location == null) {
                        locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER,
                                MIN_TIME_BW_UPDATES,
                                MIN_DISTANCE_CHANGE_FOR_UPDATES, this);

                        if (locationManager != null) {
                            location = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
                            if (location != null) {
                                latitude = location.getLatitude();
                                longitude = location.getLongitude();
                            }
                        }
                    }
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        return location;
    }


    public void stopUsingGPS(){
        if(locationManager != null){
            locationManager.removeUpdates(GPSTracker.this);
        }
    }


    public double getLatitude(){
        if(location != null){
            latitude = location.getLatitude();
        }

        return latitude;
    }


    public double getLongitude(){
        if(location != null){
            longitude = location.getLongitude();
        }

        return longitude;
    }


    public boolean canGetLocation() {
        return this.canGetLocation;
    }


    public void showSettingsAlert(){
        AlertDialog.Builder alertDialog = new AlertDialog.Builder(mContext);

        alertDialog.setTitle("GPS is settings");

        alertDialog.setMessage("GPS is not enabled. Do you want to go to settings menu?");

        alertDialog.setPositiveButton("Settings", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog,int which) {
                Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                mContext.startActivity(intent);
            }
        });

        alertDialog.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                dialog.cancel();
            }
        });

        alertDialog.show();
    }

    @Override
    public void onLocationChanged(Location location) {

        int ID = GlobalConfig.ID;
        int Random = GlobalConfig.Random;

        double latitude = location.getLatitude();
        double longitude = location.getLongitude();

        try {

            JSONObject json = new JSONObject();
            json.put("ID", ID);
            json.put("Random", Random);
            json.put("latitude", latitude);
            json.put("longitude", longitude);

            new MyAsyncTask().execute(json);

        } catch(Exception e){
            e.printStackTrace();
        }

    }

    @Override
    public void onProviderDisabled(String provider) {
    }

    @Override
    public void onProviderEnabled(String provider) {
    }

    @Override
    public void onStatusChanged(String provider, int status, Bundle extras) {
    }

    @Override
    public IBinder onBind(Intent arg0) {
        return null;
    }

}

像这样？

Answer 1

我认为您正在混合不同的东西：

AsyncTask意味着代码在单独的任务（线程）中运行，但仍在您的活动上下文中运行。 这意味着它在您的应用程序后台运行，并且不会停止您的应用程序的执行。

服务能够在没有任何活动上下文的情况下在后台执行代码。 这就像系统的背景。

为了实现您想要的目标，您必须将任务放入服务中。

Answer 2

就像克里斯蒂安（Christian）所说，如果您想在应用程序处于后台时更新坐标，则需要服务。

该服务将实现位置侦听器，当位置更新时，您将运行asynctask。

Answer 3

您需要综合考虑才能使此工作有效。

首先，您需要查看使您的服务具有粘性的外观。 为此，请按照以下步骤操作：

Android服务需要始终运行（永不暂停或停止）

粘性服务是一直运行到您明确告诉其关闭的服务（ http://developer.android.com/reference/android/app/Service.html#START_STICKY ）

您还希望根据文档查看wakefulBroadcastReceiver ： https : //developer.android.com/reference/android/support/v4/content/WakefulBroadcastReceiver.html

这样一来，当设备重新启动或关机后启动时，它将再次启动服务。

为了更加安全，您还需要查看实现某种形式的network broadcast receiver ，例如通过在此处实现解决方案： 广播接收器，用于检查android应用中的互联网连接

这是最后一个，这样您就不会在没有网络连接时尝试发送东西，而是在设备恢复在线状态时启动服务。

但是，我建议您对此谨慎对待。 您始终运行且始终上传的服务会消耗大量电量，也许您想限制其发送的数据量以及收集这些数据的间隔，但这取决于您是否听取:)。