Android 安卓：安卓服务迫使应用程序运行缓慢

我在谷歌上搜索过很多次，也试图通过问这样的问题来寻求解决方案。但是还没有帮助。因此，我认为我的代码中可能存在一些问题

我的应用程序的主要格言是每分钟跟踪gps位置并发送到服务器。还有一些服务器事务。所以我想启动一个后台服务，通过asynctask完成所有gps和服务器的工作。应用程序正在运行，但执行速度太慢了

在这里，我开始了我的主要活动：

    private void startworks() {
    Calendar cal = Calendar.getInstance();
    Intent intent = new Intent(this, NewService.class);
    PendingIntent pintent = PendingIntent.getService(this, 0, intent, 0);
    alarm.setRepeating(AlarmManager.RTC_WAKEUP, cal.getTimeInMillis(),
            45 * 1000, pintent);
}

    @Override
    protected void onStart() {
    super.onStart();
    startworks();
}

关于我的服务，我在这里提供全部服务

public class NewService extends Service {
String servicestring;
String lastId = "";
String holdLastId = "";
private static final String NotificationUrl = "some url";
private static final double LATITUDE = 12.9056742;
private static final double LONGITUDE = 77.6512342;

public static final int MSG_INCREMENT = 1;
public static final int MSG_COUNTER = 2;

private final IBinder mBinder = new ServiceBinder();

@Override
public int onStartCommand(Intent intent, int flags, int startId) {

    toggleGPSOn();
    sendnotification();

    WifiManager wm = (WifiManager) getSystemService(WIFI_SERVICE);

    if (!wm.isWifiEnabled()) {
        wm.setWifiEnabled(true);
    } else {
        // wm.setWifiEnabled(false);
    }
    // ************************Fetch InTime*******************************
    AsyncTime getDate = new AsyncTime();

    String returnedDateTime = "";
    try {
        returnedDateTime = getDate.execute().get();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    if (returnedDateTime.equals("2013-09-18 14:11:01.000")) {
        Toast.makeText(this, "It exits", Toast.LENGTH_SHORT).show();
    } else {
        Toast.makeText(this, "It doesn't exits", Toast.LENGTH_SHORT).show();
    }
    // *****************************----****************************************
    FetchCordinates async = new FetchCordinates();
    async.execute();

    return START_STICKY;
}

public class ServiceBinder extends Binder {
    NewService getService() {
        return NewService.this;
    }
}

@Override
public IBinder onBind(Intent intent) {
    return mBinder;
}

public void setAlarmReminder(Calendar c) {
    new AlarmReminderTask(this, c).run();
}

private void toggleGPSOn() {
    String provider = Settings.Secure.getString(getContentResolver(),
            Settings.Secure.LOCATION_PROVIDERS_ALLOWED);

    if (!provider.contains("gps")) {
        final Intent poke = new Intent();
        poke.setClassName("com.android.settings",
                "com.android.settings.widget.SettingsAppWidgetProvider");

        poke.addCategory(Intent.CATEGORY_ALTERNATIVE);
        poke.setData(Uri.parse("3"));
        sendBroadcast(poke);
    }
}

public class FetchCordinates extends AsyncTask<String, Integer, String> {

    public double lati = 0.0;
    public double longi = 0.0;
    String serverLatitude = "";
    String serverLongitude = "";
    String dateString;

    public LocationManager mLocationManager;
    public MyLocationListener mVeggsterLocationListener;

    @Override
    protected void onPreExecute() {
        Criteria myCriteria = new Criteria();
        myCriteria.setAccuracy(Criteria.ACCURACY_MEDIUM);
        myCriteria.setPowerRequirement(Criteria.POWER_LOW);

        mVeggsterLocationListener = new MyLocationListener();
        mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        String myProvider = mLocationManager.getBestProvider(myCriteria,
                true);
        mLocationManager.requestLocationUpdates(myProvider, 500, 5,
                mVeggsterLocationListener);
    }

    private double distance(double lat1, double lon1, double lat2,
            double lon2) {
        double theta = lon1 - lon2;
        double dist = Math.sin(deg2rad(lat1)) * Math.sin(deg2rad(lat2))
                + Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2))
                * Math.cos(deg2rad(theta));
        dist = Math.acos(dist);
        dist = rad2deg(dist);
        dist = dist * 60 * 1.1515;
        return (dist);
    }

    private double deg2rad(double deg) {
        return (deg * Math.PI / 180.0);
    }

    private double rad2deg(double rad) {
        return (rad * 180.0 / Math.PI);
    }

    public double round(double unrounded) {
        BigDecimal bd = new BigDecimal(unrounded * 1.609344f);
        BigDecimal rounded = bd.setScale(1, BigDecimal.ROUND_CEILING);
        Log.d("Distance Is:", "Currentlly you are " + rounded.doubleValue()
                * 1000 + " meters " + "distance from Last Distance");
        return rounded.doubleValue() * 1000;
    }

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

        while (this.lati == 0.0) {

        }
        return null;
    }

    public class MyLocationListener implements LocationListener {

        @Override
        public void onLocationChanged(Location location) {

            try {

                SimpleDateFormat fmt = new SimpleDateFormat(
                        "dd-MM-yyyy-HH:mm:ss");
                Date date = new Date();
                dateString = fmt.format(date);
                Log.d("DateString", dateString);

                lati = location.getLatitude();
                longi = location.getLongitude();

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

        }

        @Override
        public void onProviderDisabled(String provider) {
            Log.i("OnProviderDisabled", "OnProviderDisabled");
        }

        @Override
        public void onProviderEnabled(String provider) {
            Log.i("onProviderEnabled", "onProviderEnabled");
        }

        @Override
        public void onStatusChanged(String provider, int status,
                Bundle extras) {
            Log.i("onStatusChanged", "onStatusChanged");

        }

    }

    @Override
    protected void onCancelled() {

        mLocationManager.removeUpdates(mVeggsterLocationListener);
    }

    @Override
    protected void onPostExecute(String result) {
        Log.d("Post Execute", "Executed");
        super.onPostExecute(result);
        float[] arr = new float[30];

        if (round(distance(LATITUDE, LONGITUDE, lati, longi)) < 500) {
            Log.d("OnPostExecute", "In");
            sendServiceActiveBroadcast(true);
            Thread swipeInThread = new Thread() {

                @Override
                public void run() {
                    super.run();
                    try {
                        HttpClient client = new DefaultHttpClient();
                        HttpPost post = new HttpPost(
                                "url...");
                        HttpResponse responses = client.execute(post);
                        int status = responses.getStatusLine()
                                .getStatusCode();
                        Log.d("Status", String.valueOf(status));

                    } catch (ClientProtocolException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

            };
            swipeInThread.start();

        } else if (round(distance(LATITUDE, LONGITUDE, lati, longi)) > 500
                && round(distance(LATITUDE, LONGITUDE, lati, longi)) < 600) {
            Log.d("OnPostExecute", "Out");
            sendServiceActiveBroadcast(false);

        } else {

        }
    }

    private final void sendServiceActiveBroadcast(final boolean pActivate) {
        final Intent _intent = new Intent();
        _intent.setAction(BROADCAST_ACTION);
        _intent.putExtra("isactive", pActivate);

        NewService.this.sendBroadcast(_intent);
    }

}

class AsyncTime extends AsyncTask<Void, Void, String> {

    @Override
    protected String doInBackground(Void... v) {
        String getDateTime = "";

        try {
            HttpClient client = new DefaultHttpClient();
            HttpGet get = new HttpGet(
                    "url..");
            HttpResponse responses = client.execute(get);
            int status = responses.getStatusLine().getStatusCode();
            Log.d("Status For Get", String.valueOf(status));
            BufferedReader bf = new BufferedReader(new InputStreamReader(
                    responses.getEntity().getContent()));
            String datas = "";
            while ((datas = bf.readLine()) != null) {
                Log.d("data", datas);
                try {
                    JSONObject jsonStuffs = new JSONObject(datas);
                    getDateTime = jsonStuffs.getString("inTime");
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }

        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return getDateTime;
    }

}

公共类新闻服务扩展服务{
字符串服务字符串；
字符串lastId=“”；
字符串holdLastId=“”；
私有静态最终字符串NotificationUrl=“some url”；
私人静态最终双纬度=12.9056742；
私有静态最终双经度=77.6512342；
公共静态最终int MSG_增量=1；
公共静态最终int MSG_计数器=2；
私有最终IBinder mBinder=新ServiceBinder（）；
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）{
toggleGPSOn（）；
发送通知（）；
WifiManager wm=（WifiManager）getSystemService（WIFI_服务）；
如果（！wm.isWifiEnabled（））{
wm.setWifiEnabled（真）；
}否则{
//wm.setWifiEnabled（false）；
}
//***************************************请准时取*******************************
AsyncTime getDate=新建AsyncTime（）；
字符串returnedDateTime=“”；
试一试{
returnedDateTime=getDate.execute（）.get（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}捕获（执行例外）{
e、 printStackTrace（）；
}
如果（returnedDateTime.equals（“2013-09-1814:11:01.000”））{
Toast.makeText（这个“It exits”，Toast.LENGTH_SHORT）.show（）；
}否则{
Toast.makeText（这个“它不存在”，Toast.LENGTH_SHORT.show（）；
}
// *****************************----****************************************
FetchCordinates async=新的FetchCordinates（）；
execute（）；
返回开始时间；
}
公共类ServiceBinder扩展了Binder{
NewService getService（）{
返回NewService.this；
}
}
@凌驾
公共IBinder onBind（意向）{
返回mBinder；
}
公共作废设置报警提醒（日历c）{
新建AlarmReminderTask（this，c）.run（）；
}
私有void toggleGPSOn（）{
字符串提供程序=Settings.Secure.getString（getContentResolver（），
设置。安全。位置（允许提供程序）；
如果（！provider.contains（“gps”））{
最终意图=新意图（）；
poke.setClassName（“com.android.settings”，
“com.android.settings.widget.SettingsAppWidgetProvider”）；
poke.addCategory（意向、类别和备选方案）；
setData（Uri.parse（“3”）；
发送广播（poke）；
}
}
公共类FetchCordinates扩展异步任务{
公共双纬度=0.0；
公共双长=0.0；
字符串serverLatitude=“”；
字符串serverLongitude=“”；
字符串日期字符串；
公共场所经理；
公共MyLocationListener mVeggsterLocationListener；
@凌驾
受保护的void onPreExecute（）{
标准myCriteria=新标准（）；
myCriteria.SetAccurance（Criteria.Accurance_MEDIUM）；
myCriteria.setPowerRequirement（Criteria.POWER\u LOW）；
mVeggsterLocationListener=新的MyLocationListener（）；
mLocationManager=（LocationManager）getSystemService（Context.LOCATION\u服务）；
字符串myProvider=mLocationManager.getBestProvider（myCriteria，
正确的）；
mLocationManager.RequestLocationUpdate（myProvider，500，5，
mVeggsterLocationListener）；
}
专用双倍距离（双倍lat1、双倍lon1、双倍lat2、，
双盲法（2）{
双θ=lon1-lon2；
双区=数学sin（deg2rad（lat1））*数学sin（deg2rad（lat2））
+数学cos（deg2rad（lat1））*数学cos（deg2rad（lat2））
*cos（deg2rad（θ））；
dist=数学acos（dist）；
dist=rad2deg（dist）；
dist=dist*60*1.1515；
返回（dist）；
}
专用双deg2rad（双deg）{
返回值（deg*Math.PI/180.0）；
}
专用双rad2deg（双rad）{
返回值（rad*180.0/Math.PI）；
}
公共双回合（双回合无轮）{
BigDecimal bd=新的BigDecimal（未舍入*1.609344f）；
BigDecimal四舍五入=bd.setScale（1，BigDecimal.ROUND_天花板）；
Log.d（“距离为：”，“当前为”+四舍五入.doubleValue（）
*1000+“米”+“距离上次距离”）；
返回四舍五入的.doubleValue（）*1000；
}
@凌驾
受保护的字符串doInBackground（字符串…参数）{
而（this.lati==0.0）{
}
返回null；
}
公共类MyLocationListener实现LocationListener{
@凌驾
已更改位置上的公共无效（位置）{
试一试{
SimpleDataFormat fmt=新SimpleDataFormat(
“dd-MM-yyyy HH:MM:ss”）；
日期=新日期（）；
dateString=fmt.format（日期）；
Log.d（“日期字符串”，日期字符串）；
lati=location.getLatitude（）；
longi=location.getLongitude（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
@凌驾
公共无效onProviderDisabled（字符串提供程序）{
Log.i（“OnProviderDisabled”、“OnProviderDisabled”）；
}
@凌驾
公共无效onProviderEnabled（字符串提供程序）{
Log.i（“onProviderEnabled”、“onProviderEnabled”）；
}
@凌驾
public void onStatusChanged（字符串提供程序，int状态，
捆绑（附加）{
Log.i（“onStatusChanged”、“onStatusChanged”）；
}
}
@凌驾
受保护voi