Ⅰ android开发怎么调试Service
Android开发如何调试Service
Android 开发中，添加代码对Service 进行调试 。
介绍
以调试 模式启动Android 项目时，在service 中设置断点，调试 器不会停止下来
解决方法
所有的这种情况下，都是在代码中声明。调用的方法是：
android.os.Debug.waitForDebugger();
举个例子，SoftKeyboard：
public class SoftKeyboard extends InputMethodService implements KeyboardView.OnKeyboardActionListener { @Override public void onConfigurationChanged(Configuration newConfig) { Log.d("SoftKeyboard", "onConfigurationChanged()"); /* now let's wait until the debugger attaches */ android.os.Debug.waitForDebugger(); super.onConfigurationChanged(newConfig); /* do something useful... */ }
代码中你可以看到，首先是调用了日志记录器logger，代码运行到这里时，会将在logcat中添加一条记录，这是跟踪代码运行的一种方法，如果不需要在断点上停止时可以使用。但通常为了更详细的调试 ，这是不足够的。
第二条语句等待添加调试 器，添加了这条语句之后，可以在这个方法的任何地方添加断点。
Activity也是应用的部分时调试 Service 就更加容易了。那种情况下，首先需要启动Activity，调试 器也可以在Service 的断点中停止下来，不需要调用 waitForDebugger()。
Ⅱ 如何写android service
android SDK提供了Service，用于类似*nix守护进程或者windows的服务。
Service有两种类型：
1. 本地服务（Local Service）：用于应用程序内部
2. 远程服务（Remote Sercie）：用于android系统内部的应用程序之间
前者用于实现应用程序自己的一些耗时任务，比如查询升级信息，并不占用应用程序比如Activity所属线程，而是单开线程后台执行，这样用户体验比较好。
后者可被其他应用程序复用，比如天气预报服务，其他应用程序不需要再写这样的服务，调用已有的即可。
编写不需和Activity交互的本地服务示例
本地服务编写比较简单。首先，要创建一个Service类，该类继承android的Service类。这里写了一个计数服务的类，每秒钟为计数器加一。在服务类的内部，还创建了一个线程，用于实现后台执行上述业务逻辑。
package com.easymorse;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
public class CountService extends Service {
private boolean threadDisable;
private int count;
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onCreate() {
super.onCreate();
new Thread(new Runnable() {
@Override
public void run() {
while (!threadDisable) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
count++;
Log.v("CountService", "Count is " + count);
}
}
}).start();
}
@Override
public void onDestroy() {
super.onDestroy();
this.threadDisable = true;
Log.v("CountService", "on destroy");
}
public int getCount() {
return count;
}
}
需要将该服务注册到配置文件AndroidManifest.xml中，否则无法找到：
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.easymorse" android:versionCode="1" android:versionName="1.0">
<application android:icon="@drawable/icon" android:label="@string/app_name">
<activity android:name=".LocalServiceDemoActivity"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<service android:name="CountService" />
</application>
<uses-sdk android:minSdkVersion="3" />
</manifest>
在Activity中启动和关闭本地服务。
package com.easymorse;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
public class LocalServiceDemoActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
this.startService(new Intent(this, CountService.class));
}
@Override
protected void onDestroy() {
super.onDestroy();
this.stopService(new Intent(this, CountService.class));
}
}
Ⅲ android中当Service在运行时怎么重启Service
只需要重新startService即可重新调用service的onStart()。
Service是在一段不定的时间运行在后台，不和用户交互应用组件。每个Service必须在manifest中 通过<service>来声明。可以通过contect.startservice和contect.bindserverice来启动。
Service和其他的应用组件一样，运行在进程的主线程中。这就是说如果service需要很多耗时或者阻塞的操作，需要在其子线程中实现。
service的两种模式(startService()/bindService() ：
1.本地服务 Local Service 用于应用程序内部。
它可以启动并运行，直至有人停止了它或它自己停止。在这种方式下，它以调用Context.startService()启动，而以调用Context.stopService()结束。它可以调用Service.stopSelf() 或 Service.stopSelfResult()来自己停止。不论调用了多少次startService()方法，你只需要调用一次stopService()来停止服务。
用于实现应用程序自己的一些耗时任务，比如查询升级信息，并不占用应用程序比如Activity所属线程，而是单开线程后台执行，这样用户体验比较好。
2.远程服务 Remote Service 用于android系统内部的应用程序之间。
它可以通过自己定义并暴露出来的接口进行程序操作。客户端建立一个到服务对象的连接，并通过那个连接来调用服务。连接以调用Context.bindService()方法建立，以调用 Context.unbindService()关闭。多个客户端可以绑定至同一个服务。如果服务此时还没有加载，bindService()会先加载它。
Ⅳ android中service常驻
在AndroidManifest中声明Activity或者Service时,定义android:process属性
格式:android:process=":{进程名字}",这样就能运行在其他进程了
详见:http://developer.android.com/guide/topics/manifest/service-element.html
当把service跑在其他进程后,就可解决,方法参考1
按推荐做法的话,可以像Google提供的绝大多数服务那样,使用Content Provider,具体使用方式请自行搜索.另外,可以采用AIDL跟其他进程的Service直接进行通信,我们之前的做法会做一套序列/反序列化的东西在公共Service和其他普通app进行通信(当然也是通过AIDL).至于Service可以不用单独装,在你的业务app里捆绑一个小的Service也就可以了
http://segmentfault.com/q/1010000000415917
Ⅳ Android中怎么启动关闭Service及功能解释
解惑：
1、 Service不是分离开的进程，除非其他特殊情况，它不会运行在自己的进程，而是作为启动运行它的进程的一部分。
2、 Service不是线程，这意味着它将在主线程里劳作。
启动service有两种方法：
1、 Context.startService()
调用者与服务之间没有关联，即使调用者退出，服务仍可运行
2、 Context.bindService()
调用者与服务绑定在一起，调用者一旦退出，服务也就终止
Service的生命周期
如果使用startService()启动service，系统将通过传入的Intent在底层搜索相关符合Intent里面信息的service。如果服务没有启动则先运行onCreate，然后运行onStartCommand （可在里面处理启动时传过来的Intent和其他参数），直到明显调用stopService或者stopSelf才将停止Service。无论运行startService多少次，只要调用一次stopService或者stopSelf，Service都会停止。使用stopSelf(int)方法可以保证在处理好intent后再停止。
控制service运行的主要方式有两种，主要是根据onStartCommand方法返回的数值。方法：
1、START_STICKY
2、START_NOT_STICKY or START_REDELIVER_INTENT
这里主要解释这三个变量的意义：
1、 START_STICKY
在运行onStartCommand后service进程被kill后，那将保留在开始状态，但是不保留那些传入的intent。不久后service就会再次尝试重新创建，因为保留在开始状态，在创建 service后将保证调用onstartCommand。如果没有传递任何开始命令给service，那将获取到null的intent
2、 START_NOT_STICKY
在运行onStartCommand后service进程被kill后，并且没有新的intent传递给它。Service将移出开始状态，并且直到新的明显的方法（startService）调用才重新创建。因为如果没有传递任何未决定的intent那么service是不会启动，也就是期间onstartCommand不会接收到任何null的intent。
3、 START_REDELIVER_INTENT
在运行onStartCommand后service进程被kill后，系统将会再次启动service，并传入最后一个intent给onstartCommand。直到调用stopSelf(int)才停止传递intent。如果在被kill后还有未处理好的intent，那被kill后服务还是会自动启动。因此onstartCommand不会接收到任何null的intent。
客户端也可以使用bindService来保持跟service持久关联。谨记：如果使用这种方法，那么将不会调用onstartCommand（跟startService不一样，下面例子注释也有解析，大家可试试）。客户端将会在onBind回调中接收到IBinder接口返回的对象。通常IBinder作为一个复杂的接口通常是返回aidl数据。
Service也可以混合start和bind一起使用。
权限
要运行service，首先必须在AndroidManifest.xml里申明<service>标签。
Service能够保护个人的IPC调用，所以在执行实现该调用时前先使用checkCallingPermission(String) 方法检查是否有这个权限。
进程生命周期
当service运行在低内存的环境时，将会kill掉一下存在的进程。因此进程的优先级将会很重要：
1、 如果service当前正在执行onCreate、onStartCommand、onDestroy方法，主进程将会成为前台进程来保证代码可以执行完成避免被kill
2、 如果service已经启动了，那么主进程将会比其他可见的进程的重要性低，但比其他看不见的进程高。因为只有少部分进程始终是用户可见的，因此除非在极度低内存的时候，不然 service是不会被kill的。
3、 如果有客户端关联到service，那么service永远比客户端重要。也就是说客户端可见，那么service也可见（我理解这里的可见并不是可以看到，而是重要性，因为可见往往就表示重要性高）。
4、 Service可以使用startForeground API将service放到前台状态。这样在低内存时被kill的几率更低，但是文档后面又写了，如果在极度极度低内存的压力下，该service理论上还是会被kill掉。但这个情况基本不用考虑。
当然如果service怎么保持还是被kill了，那你可以通过重写onStartCommand返回变量来设置它的启动方式。比如：START_STICKY、START_REDELIVER_INTENT等等，前面已经讨论了它们的作用，这里就不再累赘了
Ⅵ android 中 service 如果作为 内部类 的话怎么在配置文件中被注册啊
内部类不可以
Service 是android的一种机制，当它运行的时候如果是Local Service，那么对应的 Service 是运行在主进程的 main 线程上的。如：onCreate，onStart 这些函数在被系统调用的时候都是在主进程的 main 线程上运行的。如果是Remote Service，那么对应的 Service 则是运行在独立进程的 main 线程上。
Ⅶ AndroidService是什么
Service就是一个应用程序组件，用来执行一些长时间的操作，然而不与用户交互或者为其他应用程序提供一些功能。每一个Service类都必须定义在AndroidManifest.xml中，以<service>tag开头。
Ⅷ android service权限问题
问题一：可以用，因为权限是面向整个应用程序的，不是面向某个类。
问题二：在声明service的xml代码里添加android:permission标签。
<service android:name="xxx"
android:permission="xxxx">
也可以在<application>标签下直接申明多个permission, 其实就是问题一的做法。
Ⅸ android如何判断后台一个Service是否在运行
当你了解Service的生命周期以后,你就会明白,你可以在onStop 或者onDestroy()中记录一下状态,onStop 执行以后,那么service肯定是停止的，Service是在一段不定的时间运行在后台，不和用户交互应用组件。每个Service必须在manifest中 通过<service>来声明。可以通过contect.startservice和contect.bindserverice来启动。
Service生命周期
使用context.startService() 启动Service是会会经历:
context.startService() ->onCreate()- >onStart()->Service running
context.stopService() | ->onDestroy() ->Service stop
在Service每一次的开启关闭过程中，只有onStart可被多次调用(通过多次startService调用)，其他onCreate，onBind，onUnbind，onDestory在一个生命周期中只能被调用一次。
而启动service，根据onStartCommand的返回值不同，有两个附加的模式：
1. START_STICKY 用于显示启动和停止service。
2. START_NOT_STICKY或START_REDELIVER_INTENT用于有命令需要处理时才运行的模式。
Service不能自己运行，需要通过调用Context.startService()或Context.bindService()方法启动服务。这两个方法都可以启动Service，但是它们的使用场合有所不同。
使用startService()方法启用服务，调用者与服务之间没有关连，即使调用者退出了，服务仍然运行。如果打算采用Context.startService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onStart()方法。如果调用startService()方法前服务已经被创建，多次调用startService()方法并不会导致多次创建服务，但会导致多次调用onStart()方法。采用startService()方法启动的服务，只能调用Context.stopService()方法结束服务，服务结束时会调用onDestroy()方法。
使用bindService()方法启用服务，调用者与服务绑定在了一起，调用者一旦退出，服务也就终止，大有“不求同时生，必须同时死”的特点。onBind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务绑定时被调用，当调用者与服务已经绑定，多次调用Context.bindService()方法并不会导致该方法被多次调用。采用Context.bindService()方法启动服务时只能调用onUnbind()方法解除调用者与服务解除，服务结束时会调用onDestroy()方法。
官方文档告诉我们，Android系统会尽量保持拥有service的进程运行，只要在该service已经被启动(start)或者客户端连接(bindService)到它。当内存不足时，需要保持，拥有service的进程具有较高的优先级。
1. 如果service正在调用onCreate,onStartCommand或者onDestory方法，那么用于当前service的进程则变为前台进程以避免被killed。
2. 如果当前service已经被启动(start)，拥有它的进程则比那些用户可见的进程优先级低一些，但是比那些不可见的进程更重要，这就意味着service一般不会被killed.
3. 如果客户端已经连接到service (bindService),那么拥有Service的进程则拥有最高的优先级，可以认为service是可见的。
4. 如果service可以使用startForeground(int, Notification)方法来将service设置为前台状态，那么系统就认为是对用户可见的，并不会在内存不足时killed。