免费观看又色又爽又黄的小说免费_美女福利视频国产片_亚洲欧美精品_美国一级大黄大色毛片

Android中Service怎么用-創新互聯

這篇文章主要介紹了Android中Service怎么用，具有一定借鑒價值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。

創新互聯公司是一家集網站建設,茂南企業網站建設,茂南品牌網站建設,網站定制,茂南網站建設報價,網絡營銷,網絡優化,茂南網站推廣為一體的創新建站企業，幫助傳統企業提升企業形象加強企業競爭力。可充分滿足這一群體相比中小企業更為豐富、高端、多元的互聯網需求。同時我們時刻保持專業、時尚、前沿，時刻以成就客戶成長自我，堅持不斷學習、思考、沉淀、凈化自己，讓我們為更多的企業打造出實用型網站。

Service通常總是稱之為“后臺服務”，其中“后臺”一詞是相對于前臺而言的，具體是指其本身的運行并不依賴于用戶可視的UI界面，因此，從實際業務需求上來理解，Service的適用場景應該具備以下條件：

1.并不依賴于用戶可視的UI界面（當然，這一條其實也不是絕對的，如前臺Service就是與Notification界面結合使用的）；

2.具有較長時間的運行特性。

1.Service AndroidManifest.xml 聲明

一般而言，從Service的啟動方式上，可以將Service分為Started Service和Bound Service。無論哪種具體的Service啟動類型，都是通過繼承Service基類自定義而來。在使用Service時，要想系統能夠找到此自定義Service，無論哪種類型，都需要在AndroidManifest.xml中聲明，語法格式如下：

<service android:enabled=["true" | "false"]
 android:exported=["true" | "false"]
 android:icon="drawable resource"
 android:isolatedProcess=["true" | "false"]
 android:label="string resource"
 android:name="string"
 android:permission="string"
 android:process="string" >
 . . .
</service>

其中，android:exported屬性上一篇博文中對此已進行詳盡描述，android:name對應Service類名，android:permission是權限聲明，android:process設置具體的進程名稱。需要注意的是Service能否單獨使用一個進程與其啟動方式有關，本后下面會給出具體說明。其他的屬性此處與其他組件基本相同，不再過多描述。

注：如果自定義Service沒有在AndroidManifest.xml中聲明，當具體使用時，不會像Activity那樣直接崩潰報錯，對于顯式Intent啟動的Service，此時也會給出waring信息“IllegalArgumentException: Service not registered”，有時候不容易發現忘了聲明而一時定位不到問題。

2.Started Service

Started Service相對比較簡單，通過context.startService(Intent serviceIntent)啟動Service，context.stopService(Intent serviceIntent)停止此Service。當然，在Service內部，也可以通過stopSelf(...)方式停止其本身。

1)Started Service自定義

下面代碼片段顯示的是一個最基本的Started Service的自定義方式：

public class MyService extends Service {
 public static final String TAG = "MyService";
 @Override
 public IBinder onBind(Intent intent) {
  return null;
 }
 @Override
 public void onCreate() {
  super.onCreate();
  Log.w(TAG, "in onCreate");
 }
 @Override
 public int onStartCommand(Intent intent, int flags, int startId) {
  Log.w(TAG, "in onStartCommand");
  Log.w(TAG, "MyService:" + this);
  String name = intent.getStringExtra("name");
  Log.w(TAG, "name:" + name);
  return START_STICKY;
 }
 @Override
 public void onDestroy() {
  super.onDestroy();
  Log.w(TAG, "in onDestroy");
 }
}

其中，onBind(...)函數是Service基類中的唯一抽象方法，子類都必須重寫實現，此函數的返回值是針對Bound Service類型的Service才有用的，在Started Service類型中，此函數直接返回 null 即可。onCreate(...)、onStartCommand(...)和onDestroy()都是Started Service相應生命周期階段的回調函數。

2) Started Service使用

public class MainActivity extends Activity {
 public static final String TAG = "MainActivity";
 private Button startServiceBtn;
 private Button stopServideBtn;
 private Button goBtn;
 private Intent serviceIntent;
 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  startServiceBtn = (Button) findViewById(R.id.start_service);
  stopServideBtn = (Button) findViewById(R.id.stop_service);
  goBtn = (Button) findViewById(R.id.go);
  startServiceBtn.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View v) {
    serviceIntent = new Intent(MainActivity.this, MyService.class);
    startService(serviceIntent);
   }
  });
  stopServideBtn.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View v) {
    stopService(serviceIntent);
   }
  });
  goBtn.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View v) {
    Intent intent = new Intent(MainActivity.this, BActivity.class);
    startActivity(intent);
   }
  });
 }
 @Override
 protected void onDestroy() {
  super.onDestroy();
  Log.w(TAG, "in onDestroy");
 }
}

如上代碼片段，

當Client調用startService(Intent serviceIntent)后，如果MyService是第一次啟動，首先會執行 onCreate()回調，然后再執行onStartCommand(Intent intent, int flags, int startId)，當Client再次調用startService(Intent serviceIntent)，將只執行onStartCommand(Intent intent, int flags, int startId)，因為此時Service已經創建了，無需執行onCreate()回調。無論多少次的startService，只需要一次stopService()即可將此Service終止，執行onDestroy()函數（其實很好理解，因為onDestroy()與onCreate()回調是相對的）。

下面重點關注下onStartCommand(Intent intent, int flags, int startId)方法。

其中參數flags默認情況下是0，對應的常量名為START_STICKY_COMPATIBILITY。startId是一個唯一的整型，用于表示此次Client執行startService(...)的請求請求標識，在多次startService(...)的情況下，呈現0,1,2....遞增。另外，此函數具有一個int型的返回值，具體的可選值及含義如下：

START_NOT_STICKY：當Service因為內存不足而被系統kill后，接下來未來的某個時間內，即使系統內存足夠可用，系統也不會嘗試重新創建此Service。除非程序中Client明確再次調用startService(...)啟動此Service。

START_STICKY：當Service因為內存不足而被系統kill后，接下來未來的某個時間內，當系統內存足夠可用的情況下，系統將會嘗試重新創建此Service，一旦創建成功后將回調onStartCommand(...)方法，但其中的Intent將是null，pendingintent除外。

START_REDELIVER_INTENT：與START_STICKY唯一不同的是，回調onStartCommand(...)方法時，其中的Intent將是非空，將是最后一次調用startService(...)中的intent。

START_STICKY_COMPATIBILITY：compatibility version of {@link #START_STICKY} that does not guarantee that {@link #onStartCommand} will be called again after being killed。此值一般不會使用，所以注意前面三種情形就好。

以上的描述中，”當Service因為內存不足而被系統kill后“一定要非常注意，因為此函數的返回值設定只是針對此種情況才有意義的，換言之，當認為的kill掉Service進程，此函數返回值無論怎么設定，接下來未來的某個時間內，即使系統內存足夠可用，Service也不會重啟。

小米手機針對此處做了變更：

另外，需要注意的是，小米手機針對此處做了一定的修改。在“自啟動管理”中有一個自啟動應用列表，默認情況下，只有少應用（如微信、QQ、YY、360等）默認是可以自啟動的，其他應用默認都是禁止的。用戶可以手動添加自啟動應用，添加后的應用中如果Started Service onStartCommand(...)回調返回值是START_STICKY或START_REDELIVER_INTENT，當用戶在小米手機上長按Home鍵結束App后，接下來未來的某個時間內，當系統內存足夠可用時，Service依然可以按照上述規定重啟。當然，如果用戶在 設置 >> 應用 >> 強制kill掉App進程，此時Service是不會重啟的。

注：以上實驗結論基于小米2S親測。

3) Started Service生命周期及進程相關

1.onCreate(Client首次startService(..)) >> onStartCommand >> onStartCommand - optional ... >> onDestroy(Client調用stopService(..))

注：onStartCommand(..)可以多次被調用，onDestroy()與onCreate()想匹配，當用戶強制kill掉進程時，onDestroy()是不會執行的。

2.對于同一類型的Service，Service實例一次永遠只存在一個，而不管Client是否是相同的組件，也不管Client是否處于相同的進程中。

3.Service通過startService(..)啟動Service后，此時Service的生命周期與Client本身的什么周期是沒有任何關系的，只有Client調用stopService(..)或Service本身調用stopSelf(..)才能停止此Service。當然，當用戶強制kill掉Service進程或系統因內存不足也可能kill掉此Service。

4.Client A 通過startService(..)啟動Service后,可以在其他Client（如Client B、Client C）通過調用stopService(..)結束此Service。

5.Client調用stopService(..)時，如果當前Service沒有啟動，也不會出現任何報錯或問題，也就是說，stopService(..)無需做當前Service是否有效的判斷。

6.startService(Intent serviceIntent)，其中的intent既可以是顯式Intent，也可以是隱式Intent，當Client與Service同處于一個App時，一般推薦使用顯示Intent。當處于不同App時，只能使用隱式Intent。

當Service需要運行在單獨的進程中，AndroidManifest.xml聲明時需要通過android:process指明此進程名稱，當此Service需要對其他App開放時，android:exported屬性值需要設置為true(當然，在有intent-filter時默認值就是true)。

<service
 android:name=".MyService"
 android:exported="true"
 android:process=":MyCorn" >
 <intent-filter>
  <action android:name="com.example.androidtest.myservice" />
 </intent-filter>
</service>

4)Started Service Client與Service通信相關

當Client調用startService(Intent serviceIntent)啟動Service時，Client可以將參數通過Intent直接傳遞給Service。Service執行過程中，如果需要將參數傳遞給Client，一般可以通過借助于發送廣播的方式（此時，Client需要注冊此廣播）。

3.Bound Service

相對于Started Service，Bound Service具有更多的知識點。Bound Service的主要特性在于Service的生命周期是依附于Client的生命周期的，當Client不存在時，Bound Service將執行onDestroy，同時通過Service中的Binder對象可以較為方便進行Client-Service通信。Bound Service一般使用過程如下：

1.自定義Service繼承基類Service，并重寫onBind(Intent intent)方法，此方法中需要返回具體的Binder對象；

2.Client通過實現ServiceConnection接口來自定義ServiceConnection，并通過bindService (Intent service, ServiceConnection sc, int flags)方法將Service綁定到此Client上；

3.自定義的ServiceConnection中實現onServiceConnected(ComponentName name, IBinder binder)方法，獲取Service端Binder實例；

4.通過獲取的Binder實例進行Service端其他公共方法的調用，以完成Client-Service通信；

5.當Client在恰當的生命周期（如onDestroy等）時，此時需要解綁之前已經綁定的Service，通過調用函數unbindService(ServiceConnection sc)。

在Bound Service具體使用過程中，根據onBind(Intent intent)方法放回的Binder對象的定義方式不同，又可以將其分為以下三種方式，且每種方式具有不同的特點和適用場景：

1）.Extending the Binder class

這是Bound Service中最常見的一種使用方式，也是Bound Service中最簡單的一種。

局限：Clinet與Service必須同屬于同一個進程，不能實現進程間通信（IPC）。否則則會出現類似于“android.os.BinderProxy cannot be cast to xxx”錯誤。

下面通過代碼片段看下具體的使用：

public class MyBindService extends Service {
 public static final String TAG = "MyBindService";
 private MyBinder mBinder = new MyBinder();
 public class MyBinder extends Binder {
  MyBindService getService() {
   return MyBindService.this;
  }
 }
 @Override
 public void onCreate() {
  super.onCreate();
  Log.w(TAG, "in onCreate");
 }
 @Override
 public IBinder onBind(Intent intent) {
  Log.w(TAG, "in onBind");
  return mBinder;
 }
 @Override
 public boolean onUnbind(Intent intent) {
  Log.w(TAG, "in onUnbind");
  return super.onUnbind(intent);
 }
 @Override
 public void onDestroy() {
  super.onDestroy();
  Log.w(TAG, "in onDestroy");
 }
}
public class BActivity extends Activity {
 public static final String TAG = "BActivity";
 private Button bindServiceBtn;
 private Button unbindServiceBtn;
 private Button startIntentService;
 private Intent serviceIntent;
 private ServiceConnection sc = new MyServiceConnection();
 private MyBinder mBinder;
 private MyBindService mBindService;
 private boolean mBound;
 private class MyServiceConnection implements ServiceConnection {
  @Override
  public void onServiceConnected(ComponentName name, IBinder binder) {
   Log.w(TAG, "in MyServiceConnection onServiceConnected");
   mBinder = (MyBinder) binder;
   mBindService = mBinder.getService();
   mBound = true;
  }
  @Override
  public void onServiceDisconnected(ComponentName name) {
   // This is called when the connection with the service has been
   // unexpectedly disconnected -- that is, its process crashed.
   Log.w(TAG, "in MyServiceConnection onServiceDisconnected");
   mBound = false;
  }
 }
 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.b);
  bindServiceBtn = (Button) findViewById(R.id.bind_service);
  unbindServiceBtn = (Button) findViewById(R.id.unbind_service);
  startIntentService = (Button) findViewById(R.id.start_intentservice);
  bindServiceBtn.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View v) {
    Intent intent = new Intent(BActivity.this, MyBindService.class);
    bindService(intent, sc, Context.BIND_AUTO_CREATE);
   }
  });
  unbindServiceBtn.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View v) {
    excuteUnbindService();
   }
  });
  startIntentService.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View v) {
    Intent intent = new Intent(BActivity.this, MyIntentService.class);
    startService(intent);
   }
  });
 }
 private void excuteUnbindService() {
  if (mBound) {
   unbindService(sc);
   mBound = false;
  }
 }
 @Override
 protected void onDestroy() {
  super.onDestroy();
  Log.w(TAG, "in onDestroy");
  excuteUnbindService();
 }
}

首次點擊bindServiceBtn進行bindService(..)時，依次回調順序如下：

MyBindService(13457): in onCreate
MyBindService(13457): in onBind
BActivity(13457): in MyServiceConnection onServiceConnected

再次點擊bindServiceBtn按鈕時，發現沒有任何輸出，說明MyBindService沒有進行任何回調。

點擊unbindServiceBtn進行unbindService(..)時，回調順序為：

MyBindService(13457): in onUnbind
MyBindService(13457): in onDestroy

注：在四大基本組件中，需要注意的的是BroadcastReceiver不能作為Bound Service的Client，因為BroadcastReceiver的生命周期很短，當執行完onReceive(..)回調時，BroadcastReceiver生命周期完結。而Bound Service又與Client本身的生命周期相關，因此，Android中不允許BroadcastReceiver去bindService(..)，當有此類需求時，可以考慮通過startService(..)替代。

2）Using a Messenger

Messenger，在此可以理解成”信使“，通過Messenger方式返回Binder對象可以不用考慮Clinet - Service是否屬于同一個進程的問題，并且，可以實現Client - Service之間的雙向通信。極大方便了此類業務需求的實現。

局限：不支持嚴格意義上的多線程并發處理，實際上是以隊列去處理

下面直接看下具體的使用：

public class MyMessengerService extends Service {
 public static final String TAG = "MyMessengerService";
 public static final int MSG_FROM_CLIENT_TO_SERVER = 1;
 public static final int MSG_FROM_SERVER_TO_CLIENT = 2;
 private Messenger mClientMessenger;
 private Messenger mServerMessenger = new Messenger(new ServerHandler());
 @Override
 public IBinder onBind(Intent intent) {
  Log.w(TAG, "in onBind");
  return mServerMessenger.getBinder();
 }
 class ServerHandler extends Handler {
  @Override
  public void handleMessage(Message msg) {
   Log.w(TAG, "thread name:" + Thread.currentThread().getName());
   switch (msg.what) {
   case MSG_FROM_CLIENT_TO_SERVER:
    Log.w(TAG, "receive msg from client");
    mClientMessenger = msg.replyTo;
    // service發送消息給client
    Message toClientMsg = Message.obtain(null, MSG_FROM_SERVER_TO_CLIENT);
    try {
     Log.w(TAG, "server begin send msg to client");
     mClientMessenger.send(toClientMsg);
    } catch (RemoteException e) {
     e.printStackTrace();
    }
    break;
   default:
    super.handleMessage(msg);
   }
  }
 }
 @Override
 public boolean onUnbind(Intent intent) {
  Log.w(TAG, "in onUnbind");
  return super.onUnbind(intent);
 }
 @Override
 public void onDestroy() {
  Log.w(TAG, "in onDestroy");
  super.onDestroy();
 }
}
public class CActivity extends Activity {
 public static final String TAG = "CActivity";
 private Button bindServiceBtn;
 private Button unbindServiceBtn;
 private Button sendMsgToServerBtn;
 private ServiceConnection sc = new MyServiceConnection();
 private boolean mBound;
 private Messenger mServerMessenger;
 private Handler mClientHandler = new MyClientHandler();
 private Messenger mClientMessenger = new Messenger(mClientHandler);
 private class MyClientHandler extends Handler {
  @Override
  public void handleMessage(Message msg) {
   if (msg.what == MyMessengerService.MSG_FROM_SERVER_TO_CLIENT) {
    Log.w(TAG, "reveive msg from server");
   }
  }
 }
 private class MyServiceConnection implements ServiceConnection {
  @Override
  public void onServiceConnected(ComponentName name, IBinder binder) {
   Log.w(TAG, "in MyServiceConnection onServiceConnected");
   mServerMessenger = new Messenger(binder);
   mBound = true;
  }
  @Override
  public void onServiceDisconnected(ComponentName name) {
   // This is called when the connection with the service has been
   // unexpectedly disconnected -- that is, its process crashed.
   Log.w(TAG, "in MyServiceConnection onServiceDisconnected");
   mBound = false;
  }
 }
 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.c);
  bindServiceBtn = (Button) findViewById(R.id.bind_service);
  unbindServiceBtn = (Button) findViewById(R.id.unbind_service);
  sendMsgToServerBtn = (Button) findViewById(R.id.send_msg_to_server);
  bindServiceBtn.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View v) {
    Intent intent = new Intent(CActivity.this, MyMessengerService.class);
    bindService(intent, sc, Context.BIND_AUTO_CREATE);
   }
  });
  unbindServiceBtn.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View v) {
    excuteUnbindService();
   }
  });
  sendMsgToServerBtn.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View v) {
    sayHello();
   }
  });
  new Handler().postDelayed(new Runnable() {
   @Override
   public void run() {
    Intent intent = new Intent(CActivity.this, MyAlarmBroadcastReceiver.class);
    sendBroadcast(intent);
   }
  }, 3 * 1000);
 }
 public void sayHello() {
  if (!mBound)
   return;
  // Create and send a message to the service, using a supported 'what' value
  Message msg = Message.obtain(null, MyMessengerService.MSG_FROM_CLIENT_TO_SERVER, 0, 0);
  // 通過replyTo把client端的Messenger(信使)傳遞給service
  msg.replyTo = mClientMessenger;
  try {
   mServerMessenger.send(msg);
  } catch (RemoteException e) {
   e.printStackTrace();
  }
 }
 private void excuteUnbindService() {
  if (mBound) {
   unbindService(sc);
   mBound = false;
  }
 }
 @Override
 protected void onDestroy() {
  super.onDestroy();
  Log.w(TAG, "in onDestroy");
  excuteUnbindService();
 }
}

其中，需要注意的幾點是：

1.MyMessengerService自定中，通過new Messenger(new ServerHandler())創建Messenger對象，在onBind(..)回調中，通過調用Messenger對象的getBinder()方法，將Binder返回；

2.Client在ServiceConnection的onServiceConnected(..)的回調中，通過new Messenger(binder)獲取到Service傳遞過來的mServerMessenger；

3.接下來，就可以通過mServerMessenger.send(msg)方法向Service發送message，Service中的Messenger構造器中的Handler即可接收到此信息，在handleMessage(..)回調中處理；

4.至此只是完成了從Client發送消息到Service，同樣的道理，想實現Service發送消息到Client，可以在客戶端定義一個Handler，并得到相應的Messenger，在Clinet發送消息給Service時，通過msg.replyTo = mClientMessenger方式將Client信使傳遞給Service；

5.Service接收到Client信使后，獲取此信使，并通過mClientMessenger.send(toClientMsg)方式將Service消息發送給Client。

至此，完成了Client - Service之間的雙向通信流程。

3）.AIDL（Android Interface Definition Language）

一般情況下，Messenger這種方式都是可以滿足需求的，當然，通過自定義AIDL方式相對更加靈活。

這種方式需要自己在項目中自定義xxx.aidl文件，然后系統會自動在gen目錄下生成相應的接口類文件，接下來整個的流程與Messenger方式差別不大，網上也有不少實例，在此不再具體給出。

注：無論哪種方式的Bound Service，在進行unbind(..)操作時，都需要注意當前Service是否處于已經綁定狀態，否則可能會因為當前Service已經解綁后繼續執行unbind(..)會導致崩潰。這點與Started Service區別很大（如前文所述：stopService(..)無需做當前Service是否有效的判斷）。

4.Local Service VS Remote Service

Local Service：不少人又稱之為”本地服務“，是指Client - Service同處于一個進程；

Remote Service：又稱之為”遠程服務“，一般是指Service處于單獨的一個進程中。

其他使用上上文中基本上都有所述。

5.Service特性

1.Service本身都是運行在其所在進程的主線程（如果Service與Clinet同屬于一個進程，則是運行于UI線程），但Service一般都是需要進行”長期“操作，所以經常寫法是在自定義Service中處理”長期“操作時需要新建線程，以免阻塞UI線程或導致ANR；

2.Service一旦創建，需要停止時都需要顯示調用相應的方法（Started Service需要調用stopService(..)或Service本身調用stopSelf(..)， Bound Service需要調用unbindService(..)），否則對于Started Service將處于一直運行狀態，對于Bound Service，當Client生命周期結束時也將因此問題。也就是說，Service執行完畢后，必須人為的去停止它。

6.IntentService

IntentService是系統提供給我們的一個已經繼承自Service類的特殊類，IntentService特殊性是相對于Service本身的特性而言的：

1.默認直接實現了onBind(..)方法，直接返回null，并定義了抽象方法onHandlerIntent(..)，用戶自定義子類時，需要實現此方法；

2.onHandlerIntent(..)主要就是用來處于相應的”長期“任務的，并且已經自動在新的線程中，用戶無語自定義新線程；

3.當”長期“任務執行完畢后（也就是onHandlerIntent(..)執行完畢后），此IntentService將自動結束，無需人為調用方法使其結束；

4.IntentService處于任務時，也是按照隊列的方式一個個去處理，而非真正意義上的多線程并發方式。

下面是一個基本的繼承自IntentService的自定義Service：

public class MyIntentService extends IntentService {
 public static final String TAG = "MyIntentService";
 public MyIntentService() {
  super(TAG);
 }
 public MyIntentService(String name) {
  super(name);
 }
 @Override
 protected void onHandleIntent(Intent intent) {
  Log.w(TAG, "in onHandleIntent");
  Log.w(TAG, "thread name:" + Thread.currentThread().getName());
 }
}

7.前臺Service

Android中Service接口中還提供了一個稱之為”前臺Service“的概念。通過Service.startForeground (int id, Notification notification)方法可以將此Service設置為前臺Service。在UI顯示上，notification將是一個處于onGoing狀態的通知，使得前臺Service擁有更高的進程優先級，并且Service可以直接notification通信。

下面是一個簡單的前臺Service使用實例：

public class MyService extends Service {
 public static final String TAG = "MyService";
 @Override
 public IBinder onBind(Intent intent) {
  return null;
 }
 @Override
 public void onCreate() {
  super.onCreate();
  Log.w(TAG, "in onCreate");
 }
 @Override
 public int onStartCommand(Intent intent, int flags, int startId) {
  Log.w(TAG, "in onStartCommand");
  Log.w(TAG, "MyService:" + this);
  String name = intent.getStringExtra("name");
  Log.w(TAG, "name:" + name);
  
  Notification notification = new Notification(R.drawable.ic_launcher, "test", System.currentTimeMillis());
  Intent notificationIntent = new Intent(this, DActivity.class);
  PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntesnt, 0);
  notification.setLatestEventInfo(this, "title", "content", pendingIntent);
  startForeground(1, notification);
  
  return START_REDELIVER_INTENT;
 }
 @Override
 public void onDestroy() {
  super.onDestroy();
  Log.w(TAG, "in onDestroy");
 }
}

感謝你能夠認真閱讀完這篇文章，希望小編分享的“Android中Service怎么用”這篇文章對大家有幫助，同時也希望大家多多支持創新互聯，關注創新互聯行業資訊頻道，更多相關知識等著你來學習!

分享題目：Android中Service怎么用-創新互聯
轉載來于：http://m.newbst.com/article8/dcjdop.html

成都網站建設公司_創新互聯，為您提供定制網站、虛擬主機、網站改版、網頁設計公司、網站維護、Google

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯

成都定制網站網頁設計