我的Android应用程序即使在关闭后也会使用CPU

我的应用程序耗尽了电池。我使用了一些服务，请求被发送到url。该服务是从扩展应用程序的类调用的。下面是我的代码

public class GApplication extends Application {
private static final String TAG ="GApplication";
private HttpClient httpClient;
private DatabaseHelper databaseHelper;

@Override
public void onCreate(){
    super.onCreate();   
    startService(new Intent(this, GService.class));
    httpClient = createHttpClient();
    databaseHelper = new DatabaseHelper(this);
}

@Override
public void onLowMemory(){
    super.onLowMemory();
    shutdownHttpClient();
}

@Override
public void onTerminate(){
    super.onTerminate();
    stopService(new Intent(this, GService.class));
    shutdownHttpClient();
    databaseHelper.close();
}

private void shutdownHttpClient(){
    if(httpClient != null && httpClient.getConnectionManager() != null){
        httpClient.getConnectionManager().shutdown();
    }
}

public DatabaseHelper getDatabaseHelper(){
    if(databaseHelper == null){
        databaseHelper = new DatabaseHelper(this);
    }
    return databaseHelper;
}

public HttpClient getHttpClient(){
    return httpClient;
}

public HttpClient createHttpClient(){
    HttpParams params = new BasicHttpParams();
    HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
    HttpProtocolParams.setContentCharset(params, HTTP.DEFAULT_CONTENT_CHARSET);
    HttpProtocolParams.setUseExpectContinue(params, true);

    SchemeRegistry registry = new SchemeRegistry();
    registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
    registry.register(new Scheme("https", PlainSocketFactory.getSocketFactory(), 443));
    return new DefaultHttpClient(new ThreadSafeClientConnManager(params, registry), params);
}

public boolean isOnline(){
    boolean isConnected = false;
    try{
        ConnectivityManager manager = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo info = manager.getActiveNetworkInfo();
        isConnected = (info != null && info.isAvailable() && info.isConnected());
    }
    catch(Exception e){
        isConnected = false;
        if(e.getMessage() != null) Log.e(TAG, e.getMessage());
    }
    return isConnected;
}

}

我的Gservice课程

public class GService extends Service {
private static final String TAG = "Gservice";



public IBinder onBind(Intent intent) {
    return null;
}   


public void onCreate(){
    super.onCreate();
    Log.i(TAG, "starting GService");

    if(isOnline()){
        URI uri = URI.create("http://myserver/Android/UploadImage/newAlert.php");
        new UpdateCheckAsyncTask(getHttpClient()).execute(uri); 
    }

}



boolean isOnline(){
    return ((GApplication)getApplication()).isOnline();
}

HttpClient getHttpClient(){
    return  ((GApplication)getApplication()).getHttpClient();
}

DatabaseHelper getDatabaseHelper(){
    return  ((GApplication)getApplication()).getDatabaseHelper();
}



class UpdateCheckAsyncTask extends WebAsyncTaskBase{
    public UpdateCheckAsyncTask(HttpClient httpClient) {
        super(httpClient);
    }


    protected String doInBackground(URI... params) {
        return getHttpContent(params[0]);
    }


    protected void onProgressUpdate(Integer... progress){

    }


    protected void onPostExecute(String result){
        if(result == null){
            Log.i(TAG, "Call returned null");
            return;
        }
        try {
            Log.i(TAG, "Processsing request");
            JSONObject json = new JSONObject(result);
            new BlogDbAsyncTask(getDatabaseHelper()).execute(json);
        } catch (JSONException e) {
            if(e.getMessage() != null) Log.e(TAG, e.getMessage());
        }
    }

    class BlogDbAsyncTask extends DbAsyncTaskBase<JSONObject, Boolean, BlogInfo>{

        public BlogDbAsyncTask(DatabaseHelper database) {
            super(database);
        }

        @Override
        protected BlogInfo doInBackground(JSONObject... json) {
            BlogInfo blogInfo = new BlogInfo();
            BlogDAO dao = new BlogDAO(GService.this, getDatabaseHelper());
            try {
                Log.i(TAG, "Adding new blog entry");
                Blog blog = dao.Select(json[0].getInt("FeedId"));
                if(blog.UID == null){
                    blog.UID = json[0].getInt("FeedId");
                    blog.Text = json[0].getString("Text");
                    blog.Title = json[0].getString("Header");
                    blog.PostedOn = json[0].getString("DisplayDate");
                    blog.PostedBy = "Gservice";
                    dao.Insert(blog);

                    blogInfo.Blog = blog;
                    blogInfo.IsNew = true;
                }
            } catch (JSONException e) {
                if(e.getMessage() != null) Log.e(TAG, e.getMessage());
            }
            return blogInfo;
        }


        protected void onPostExecute(BlogInfo result){


        }

    }

    class BlogInfo{
        public Blog Blog;
        public boolean IsNew;
    }
}

公共类GService扩展服务{
私有静态最终字符串TAG=“Gservice”；
公共IBinder onBind（意向）{
返回null；
}   
public void onCreate（）{
super.onCreate（）；
Log.i（标签，“启动GService”）；
if（isOnline（））{
URI=URI.create（“http://myserver/Android/UploadImage/newAlert.php");
新的UpdateCheckAsyncTask（getHttpClient（））.execute（uri）；
}
}
布尔isOnline（）{
return（（gaapplication）getApplication（））.isOnline（）；
}
HttpClient getHttpClient（）{
返回（（GAApplication）getApplication（））.getHttpClient（）；
}
DatabaseHelper getDatabaseHelper（）{
return（（gaapplication）getApplication（））.getDatabaseHelper（）；
}
类UpdateCheckAsyncTask扩展了WebAsyncTaskBase{
公共更新checkasynctask（HttpClient-HttpClient）{
超级（httpClient）；
}
受保护字符串doInBackground（URI…参数）{
返回getHttpContent（参数[0]）；
}
受保护的void onProgressUpdate（整数…进度）{
}
受保护的void onPostExecute（字符串结果）{
如果（结果==null）{
Log.i（标记“callreturnednull”）；
返回；
}
试一试{
Log.i（标记“处理请求”）；
JSONObject json=新的JSONObject（结果）；
新的BlogDbAsyncTask（getDatabaseHelper（））.execute（json）；
}捕获（JSONException e）{
如果（e.getMessage（）！=null）Log.e（TAG，e.getMessage（））；
}
}
类BlogDbAsyncTask扩展了DbAsyncTaskBase{
公共BlogDbAsyncTask（DatabaseHelper数据库）{
超级（数据库）；
}
@凌驾
受保护的BlogInfo doInBackground（JSONObject…json）{
BlogInfo BlogInfo=新建BlogInfo（）；
BlogDAO=newblogdao（gsservice.this，getDatabaseHelper（））；
试一试{
Log.i（标签，“添加新博客条目”）；
Blog Blog=dao.Select（json[0].getInt（“FeedId”）；
如果（blog.UID==null）{
blog.UID=json[0].getInt（“FeedId”）；
blog.Text=json[0].getString（“Text”）；
blog.Title=json[0].getString（“标题”）；
blog.PostedOn=json[0].getString（“DisplayDate”）；
blog.PostedBy=“Gservice”；
插入（博客）；
blogInfo.Blog=Blog；
blogInfo.IsNew=true；
}
}捕获（JSONException e）{
如果（e.getMessage（）！=null）Log.e（TAG，e.getMessage（））；
}
返回博客信息；
}
受保护的void onPostExecute（BlogInfo结果）{
}
}
类博客信息{
公共博客；
公共服务是新的；
}
}

---

可能从来没有在GAApplication类中调用过Onterminate方法，这会使服务连续运行。请建议是否可以发现此代码中的任何问题。如果从未在设备中调用过Onterminate，请建议如何停止服务。提前感谢。

您需要使用

IntentService

而不是

服务。这样，一旦完成任务，服务将自动关闭。
您需要使用
IntentService
而不是
服务。
这样，一旦完成任务，服务将自动关闭。
不应在实际设备上调用：

此方法用于模拟流程环境。它永远不会
在生产Android设备上调用，其中进程被删除
通过简单地杀死它们，不需要任何用户代码（包括这个回调）
在这样做时执行

你应该考虑使用服务，并根据需要使用合适的服务。
如果你想知道应用程序何时“关闭”，你需要跟踪活动的状态。例如，你可以有一个全局计数器来计算活动的数量。对于每个onCreate，你增加其值。对于每个onDestroy，你减少其值。当它达到0时，意味着当前没有活动
但是，应该警告您，这并不十分准确，因为当配置发生更改时，活动将被销毁并重新创建，因此您也需要处理它

正如我所提到的，你应该考虑使用一个服务。也许在你需要的每一个活动上绑定它，并且在活动被破坏时解除绑定。甚至可以使它在前台运行并按需关闭它。都取决于你的要求。
 < P>不应该被调用在真实设备上：

此方法用于模拟流程环境。它永远不会
在生产Android设备上调用，其中进程被删除
通过简单地杀死它们，不需要任何用户代码（包括这个回调）
在这样做时执行

你应该考虑使用服务，并根据需要使用合适的服务。
如果你想知道应用程序何时“关闭”，你需要跟踪活动的状态。例如，你可以有一个全局计数器来计算活动的数量。对于每个onCreate，你增加其值。对于每个onDestroy，你减少其值。当它达到0时，意味着当前没有活动
但是，应该警告您，这并不十分准确，因为当配置发生更改时，活动将被销毁并重新创建，因此您也需要处理它

正如我所提到的，你应该考虑使用一个服务。也许在你需要的每一个活动上绑定它，并且在活动被破坏时解除绑定。甚至可以使它在前台运行并按需关闭它。一切都取决于你的需求。