Android服务 - 与startService一起使用时与BindService一起出现问题

3 回答

• 4

  我无法“看到”这个问题，所以我创建了一个应用程序，它可以完成您需要的大部分工作，作为解决方案的基础 . 它不进行网络连接或使用真正的MediaPlayer，但该服务有一个后台线程，可以输出音频 . 您可以从两个按钮开始和停止音频 . 我能够点击后退按钮，并继续听到服务，然后从图标启动应用程序并停止并重新开始播放音频 . 我认为您可以按照我的步骤操作，如果它适用于您的设备，则开始将MediaPlayer和网络代码添加到功能服务中 .

  我使用以下tutorial作为服务代码的基础，该服务代码使用消息而不是服务的Stub /接口 .

  它基于Eclipse中的一个新的Android项目，然后我只添加了两个按钮并给它们新的文本和ID . 其余的在这里：

  首先是我在MainActivity中添加的内容日食创造了：

  private final static String TAG = "MainActivity";
  // Service stuff
  Messenger myService = null;
  boolean isBound;
  private Button startBut;
  private Button stopBut;
  
  @Override
  public void onCreate(Bundle savedInstanceState)
  {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);
  
      startBut = (Button) findViewById(R.id.startAudio);
      startBut.setOnClickListener(new Button.OnClickListener(){
          public void onClick(View v){
              try
              {
                  if (myService != null && isBound)
                  {
                      Log.d(TAG, "Service Connected! sending start request");
                      Message msg = Message.obtain();
                      Bundle bundle = new Bundle();
                      bundle.putString("MyString", "start");
  
                      msg.setData(bundle);
                      myService.send(msg);
                  }
              }
              catch (Throwable th)
              {
                  Log.d(TAG, "error sending start", th);
              }
          }
      });
  
      stopBut = (Button) findViewById(R.id.stopAudio);
      stopBut.setOnClickListener(new Button.OnClickListener(){
          public void onClick(View v){
              try
              {
                  Log.d(TAG, "Service Connected! sending stop request");
  
                  Message msg = Message.obtain();
                  Bundle bundle = new Bundle();
                  bundle.putString("MyString", "stop");
  
                  msg.setData(bundle);
                  myService.send(msg);
              }
              catch (Throwable th)
              {
                  Log.d(TAG, "error sending start", th);
              }
          }
      });
  }
  
  @Override
  public boolean onCreateOptionsMenu(Menu menu)
  {
      getMenuInflater().inflate(R.menu.activity_main, menu);
      return true;
  }
  
  @Override
  protected void onPause()
  {
      super.onPause();
  
      unBindService();
  }
  
  @Override
  protected void onResume()
  {
      super.onResume();
      Log.d(TAG, "Resuming: binding to service");
      Intent intent = new Intent("com.example.audioservice.AudioPlayerService");
  
      // Start the service ourselves because we don't want it to stop when the activity/application does.
      startService(intent);
      bindService(intent, myConnection, 0);
  }
  
  private ServiceConnection myConnection = new ServiceConnection() 
  {
      public void onServiceConnected(ComponentName className, IBinder service) {
          myService = new Messenger(service);
          isBound = true;
          Log.d(TAG, "Service Connected!");
      }
  
      public void onServiceDisconnected(ComponentName className) {
          myService = null;
          isBound = false;
      }
  };
  
  public void unBindService() 
  {
      this.unbindService(myConnection);
      Log.d(TAG, "unBindService done context => " 
              + " serviceConnection => " + myConnection);
  }
  

  接下来，Manifest文件的一个小插入：

  <service android:enabled="true"  android:name="com.example.audioservice.AudioPlayerService"
           android:process=":my_process" >
           <intent-filter>
              <action android:name="com.example.audioservice.AudioPlayerService" >
           </action>
        </intent-filter>
      </service>
  

  最后是AudioPlayerService类的内容：

  public class AudioPlayerService extends Service
  {
  private static final String TAG = "AudioPlayerService";
  AudioManager audioManager;
  private boolean playing = false;
  private Player player;
  
  class IncomingHandler extends Handler
  {
      @Override
      public void handleMessage(Message msg)
      {
          Bundle data = msg.getData();
          String dataString = data.getString("MyString");
          if ("start".equalsIgnoreCase(dataString))
          {
              Log.d(TAG, "Got a start request");
              // Start playing
              playing = true;
          }
          else if ("stop".equalsIgnoreCase(dataString))
          {
              Log.d(TAG, "Got a stop request");
              // Stop playing
              playing = false;
          }
      }
  }
  
  @SuppressLint("HandlerLeak")
  final Messenger myMessenger = new Messenger(new IncomingHandler());
  
  @Override
  public IBinder onBind(Intent arg0)
  {
      Log.d(TAG, "onBind invoked");
      return myMessenger.getBinder();
  }
  
  @Override
  public boolean onUnbind(Intent intent)
  {
      Log.d(TAG, "onUnbind invoked");
      return super.onUnbind(intent);
  }
  
  @Override
  public void onCreate()
  {
      super.onCreate();
      Log.d(TAG, "onCreate");
      audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
      audioManager.loadSoundEffects();
      player = new Player();
      player.start();
  }
  
  @Override
  public void onDestroy()
  {
      Log.d(TAG, "onDestory");
      stopPlayback();
  
      super.onDestroy();
  }
  
  private void stopPlayback()
  {
      playing = false;
  }
  
  // Pointless Thread to let us know the service is still doing its thing
  class Player extends Thread
  {
      public void run()
      {
          int x = 7;
          while (1 < x)
          {
              try
              {
                  if (playing)
                  {
                      Thread.sleep(10000);
                      Log.d(TAG, ".");
                      audioManager.playSoundEffect(AudioManager.FX_KEY_CLICK);
                  }
              }
              catch (Throwable th)
              {
                  Log.d(TAG, "error in Player", th);
              }
          }
      }
  }
  }
  

  回复于 2024-04-27T05:39:11+08:00
• 0

  我看到一个应用程序的这些问题，该应用程序运行使用GPS记录车辆行程的服务 . 只需按一下按钮，服务就会启动并继续录制，如果需要，可以持续数小时 . 按下停止按钮后，服务终止 . 在录制期间，有一个界面可以传达UI上显示的某些实时数据，因此绑定/解除绑定可以处理由于轮换，后台/恢复应用程序等导致的中断/重新连接周期 .

  只要服务运行就没有问题 . 但是，当我停止录制意味着我停止服务但继续维护与服务类的绑定/解除绑定解决方案时，会出现服务泄漏消息 . 我可能尝试做的是重新设计一些东西，以便我（1）只关心在服务运行时绑定unbind，或者（2）在应用程序生命周期内始终运行服务并添加方法告诉它开始或停止录制，让其在其他时间“空闲” . 也许（1）是要走的路，维护服务连接的方法也可能不是这种方式 .

  回复于 2024-04-27T05:39:11+08:00
• 0

  为了能够重新绑定，请确保从 onUnbind 返回true，在这种情况下，当从 Activity 调用 bindService 时，将在 Service 中调用 onRebind .

  Service.java

  @Override
  public boolean onUnbind(Intent intent) {
          super.onUnbind(intent);
          /* logic */
          return true; // future binds from activity will call onRebind
  }
  
  @Override
  public void onRebind(Intent intent) {
      // Is called when activity issues a `bindService` after an `undbindService`
      super.onRebind(intent);
      /*logic*/
  }
  

  回复于 2024-04-27T05:39:11+08:00