java—当重复处理程序遇到某个条件时，如何结束它？

pnwntuvh  于 2021-07-06  发布在  Java
关注(0)|答案(2)|浏览(433)

我正在制作一个应用程序来播放设备存储器中的音频文件，我有一个seek条，它每秒钟检查音频文件的进度（播放了多长时间），并相应地更新seekbar。
音频通过在前台运行的服务播放，并显示音频正在播放的通知。
当音频结束时，我注意到处理程序仍在循环中，我想在音频结束后结束处理程序。
我目前尝试的是从处理程序运行的runnable内部结束处理程序，因为我不确定如何结束它。
主活动，在这里我从listview处理onclick，在这里您可以选择一个音频文件，还可以处理seekbar更新。

  1. import androidx.appcompat.app.AppCompatActivity;
  2. import android.content.ComponentName;
  3. import android.content.Context;
  4. import android.content.Intent;
  5. import android.content.ServiceConnection;
  6. import android.database.Cursor;
  7. import android.os.Bundle;
  8. import android.os.Handler;
  9. import android.os.IBinder;
  10. import android.provider.MediaStore;
  11. import android.util.Log;
  12. import android.view.View;
  13. import android.widget.AdapterView;
  14. import android.widget.ListView;
  15. import android.widget.SeekBar;
  16. import android.widget.SimpleCursorAdapter;
  17. import android.widget.TextView;
  19. import java.util.concurrent.TimeUnit;
  21. public class MainActivity extends AppCompatActivity {
  23.     SeekBar musicProgBar;
  24.     Handler progBarHandler = null;
  25.     Runnable r = null;
  26.     private MP3Service.MyBinder myService = null;
  27.     TextView progressText = null;
  29.     @Override
  30.     protected void onCreate(Bundle savedInstanceState)
  31.     {
  32.         super.onCreate(savedInstanceState);
  33.         setContentView(R.layout.activity_main);
  34.         musicProgBar = findViewById(R.id.musicProgressBar);
  35.         progressText = findViewById(R.id.progressText);
  36.         final ListView lv = (ListView) findViewById(R.id.musicList);
  37.         Cursor cursor = getContentResolver().query(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
  38.                 null,
  39.                 MediaStore.Audio.Media.IS_MUSIC + "!= 0",
  40.                 null,
  41.                 null);
  43.         progBarHandler = new Handler();
  44.         final int progBarDelay = 1000; // delay for the handler, making it repeat itself only every 1000 miliseconds (1 second)
  46.         lv.setAdapter(new SimpleCursorAdapter(this,
  47.                 android.R.layout.simple_list_item_1,
  48.                 cursor,
  49.                 new String[] { MediaStore.Audio.Media.DATA},
  50.                 new int[] { android.R.id.text1 }));
  52.         Intent tempIntent = new Intent(this, MP3Service.class);
  53.         startService(tempIntent);
  54.         bindService(tempIntent, serviceConnection, 0);
  56.         lv.setOnItemClickListener(new AdapterView.OnItemClickListener() {
  57.             public void onItemClick(AdapterView<?> myAdapter,
  58.                                     View myView,
  59.                                     int myItemInt,
  60.                                     long myLong) {
  61.                 Cursor c = (Cursor) lv.getItemAtPosition(myItemInt);
  62.                 String uri = c.getString(c.getColumnIndex(MediaStore.Audio.Media.DATA));
  63.                 Log.d("g53mdp", uri);
  65.                 if (myService.fetchPlayerState() != MP3Player.MP3PlayerState.STOPPED)
  66.                     myService.stopMusic();
  68.                 myService.loadMusic(uri);
  69.                 myService.playMusic();
  70.                 musicProgBar.setMax(myService.fetchDuration()); // set the max value of the seekbar to be the duration of the song
  71.                 r = new Runnable()
  72.                 {
  73.                     @Override
  74.                     public void run()
  75.                     {
  76.                         int tempInt = myService.fetchProgress();
  77.                         Log.d("progress ticking", tempInt + " " + musicProgBar.getProgress());
  78.                         musicProgBar.setProgress(tempInt); // sets the current progress of the seekbar to be the progress of the song
  79.                         long minutes = TimeUnit.MILLISECONDS.toMinutes(tempInt);
  80.                         long seconds = TimeUnit.MILLISECONDS.toSeconds(tempInt);
  81.                         if (seconds >= 60)
  82.                             seconds = seconds - 60;
  83.                         String tempString = minutes + ":" + seconds;
  84.                         progressText.setText(tempString);
  85.                         progBarHandler.postDelayed(this, progBarDelay);
  86.                         if (musicProgBar.getProgress() == myService.fetchDuration())
  87.                             progBarHandler.removeCallbacks(this);
  88.                     }
  89.                 };
  90.                 progBarHandler.post(r);
  91.             }});
  92.     }
  94.     private ServiceConnection serviceConnection = new ServiceConnection()
  95.     {
  96.         @Override
  97.         public void onServiceConnected(ComponentName name, IBinder service)
  98.         {
  99.             myService = (MP3Service.MyBinder) service;
  100.         }
  102.         @Override
  103.         public void onServiceDisconnected(ComponentName name)
  104.         {
  105.             myService = null;
  106.         }
  107.     };
  109.     public void playButClicked(View view)
  110.     {
  111.         myService.playMusic();
  112.     }
  114.     public void pauseButClicked(View view)
  115.     {
  116.         myService.pauseMusic();
  117.     }
  119.     public void stopButClicked(View view)
  120.     {
  121.         myService.stopMusic();
  122.     }
  124.     @Override
  125.     protected void onDestroy()
  126.     {
  127.         unbindService(serviceConnection);
  128.         progBarHandler.removeCallbacks(r);
  129.         super.onDestroy();
  130.     }
  131. }

奇怪的是，在ondestroy（）中，我确实使用removecallbacks来结束处理程序，而且效果很好。我知道它在runnable r中调用removecallbacks，这是通过调试和日志记录确认的。还尝试了实现一个方法，该方法专门用于删除处理程序并调用它，但运气不好。还尝试使用return。
我正在挣扎的部分是

  1. r = new Runnable()
  2.                 {
  3.                     @Override
  4.                     public void run()
  5.                     {
  6.                         int tempInt = myService.fetchProgress();
  7.                         Log.d("progress ticking", tempInt + " " + musicProgBar.getProgress());
  8.                         musicProgBar.setProgress(tempInt); // sets the current progress of the seekbar to be the progress of the song
  9.                         long minutes = TimeUnit.MILLISECONDS.toMinutes(tempInt);
  10.                         long seconds = TimeUnit.MILLISECONDS.toSeconds(tempInt);
  11.                         if (seconds >= 60)
  12.                             seconds = seconds % 60;
  13.                         String tempString = minutes + ":" + seconds;
  14.                         progressText.setText(tempString);
  15.                         progBarHandler.postDelayed(this, progBarDelay);
  16.                         if (musicProgBar.getProgress() == myService.fetchDuration())
  17.                             progBarHandler.removeCallbacks(this);
  18.                     }
  19.                 };
  20.                 progBarHandler.post(r);
  21.             }});

处理音乐播放器和播放音乐的服务

  1. import android.app.Notification;
  2. import android.app.NotificationChannel;
  3. import android.app.NotificationManager;
  4. import android.app.PendingIntent;
  5. import android.app.Service;
  6. import android.content.Intent;
  7. import android.os.Binder;
  8. import android.os.Build;
  9. import android.os.Handler;
  10. import android.os.IBinder;
  11. import android.util.Log;
  13. import androidx.annotation.Nullable;
  14. import androidx.core.app.NotificationCompat;
  16. public class MP3Service extends Service
  17. {
  18.     public static MP3Service instance = null; // implementing singleton by instantiating a reference to the instance
  19.     private final String SERVICE_ID = "100"; // id for the service
  20.     public static boolean isRunning = false; //
  21.     NotificationManager notificationManager = null;
  22.     int notificationID = 001;
  23.     private final IBinder binder = new MyBinder();
  24.     MP3Player mainPlayer;
  26.     @Nullable
  27.     @Override
  28.     public IBinder onBind(Intent intent)
  29.     {
  30.         return binder;
  31.     }
  33.     @Override
  34.     public void onRebind(Intent intent)
  35.     {
  36.         // TODO: implement Rebind for screen orientation change
  37.     }
  39.     @Override
  40.     public void onCreate()
  41.     {
  42.         instance = this;
  43.         isRunning = true;
  44.         notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
  45.         mainPlayer = new MP3Player();
  46.         super.onCreate();
  47.         Handler handler = new Handler();
  48.     }
  50.     @Override
  51.     public void onDestroy()
  52.     {
  53.         isRunning = false;
  54.         instance = null;
  55.         notificationManager.cancel(notificationID);
  56.     }
  58.     public void createNotification() 
  59.     {
  60.         CharSequence name = "MP3 Notification";
  61.         String description = "Displays a notification when a song is playing";
  62.         int importance = NotificationManager.IMPORTANCE_DEFAULT;
  63.         NotificationChannel channel = new NotificationChannel(SERVICE_ID, name, importance);
  64.         channel.setDescription(description);
  65.         notificationManager.createNotificationChannel(channel);
  67.         Intent intent = new Intent(this, MainActivity.class);
  68.         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
  69.         // when the user clicks the notification, this will bring them to the activity
  70.         PendingIntent navToMainActivity = PendingIntent.getActivity(this, 0, intent, 0);
  72.         // sets up the info and details for the notification
  73.         final NotificationCompat.Builder mNotification = new NotificationCompat.Builder(this, SERVICE_ID)
  74.                 .setSmallIcon(R.drawable.ic_launcher_background)
  75.                 .setContentTitle("MP3 Player")
  76.                 .setContentText("Playing music")
  77.                 .setContentIntent(navToMainActivity)
  78.                 .setPriority(NotificationCompat.PRIORITY_DEFAULT);
  80.         startForeground(notificationID, mNotification.build());
  81.     }
  83.     public void removeNotification()
  84.     {
  85.         stopForeground(false);
  86.         notificationManager.cancelAll();
  87.     }
  89.     public class MyBinder extends Binder
  90.     {
  91.         public void loadMusic(String filePath)
  92.         {
  93.             mainPlayer.load(filePath);
  94.         }
  96.         public void playMusic()
  97.         {
  98.             mainPlayer.play();
  99.             createNotification();
  100.         }
  102.         public void pauseMusic()
  103.         {
  104.             mainPlayer.pause();
  105.             removeNotification();
  106.         }
  108.         public void stopMusic()
  109.         {
  110.             mainPlayer.stop();
  111.             removeNotification();
  112.         }
  114.         public MP3Player.MP3PlayerState fetchPlayerState()
  115.         {
  116.             return mainPlayer.getState();
  117.         }
  119.         public int fetchDuration()
  120.         {
  121.             return mainPlayer.getDuration();
  122.         }
  124.         public int fetchProgress()
  125.         {
  126.             return mainPlayer.getProgress();
  127.         }
  128.     }
  129. }

提前感谢您的帮助，如有需要，我很乐意提供更多信息
编辑：将runnable之外的progbarhandler.postdelay（）更改为简单的progbarhandler.post（）

JavaandroidAudioHandler

2条答案

按热度按时间
ltqd579y

ltqd579y1#

我认为您未能停止处理程序的唯一原因是不断调用 progBarHandler.postDelayed(this, progBarDelay); ，您需要检查它为什么仍在运行。

赞(0）分享  回复(0）举报  2021-07-06
oxcyiej7

oxcyiej72#

通过向runnable引入不同类型的if语句，成功地使其工作，如

  1. Runnable r = new Runnable()
  2. {
  3.     @Override
  4.     public void run()
  5.     {
  6.         if (musicProgBar.getProgress() == myService.fetchProgress() && myService.fetchProgress() != 0)
  7.             Log.d("audio", "over");
  8.         else {
  9.             int tempInt = myService.fetchProgress();
  10.             long minutes = TimeUnit.MILLISECONDS.toMinutes(tempInt);
  11.             long seconds = TimeUnit.MILLISECONDS.toSeconds(tempInt);
  12.             if (seconds >= 60)
  13.                 seconds = seconds % 60;
  14.             String tempString = minutes + ":" + seconds;
  15.             progressText.setText(tempString);
  16.             musicProgBar.setProgress(tempInt); // sets the current progress of the seekbar to be the progress of the song
  17.             progBarHandler.postDelayed(this, progBarDelay);
  18.         }
  19.     }
  20. };

出于某种原因，使用.fetchduration（）和.fetchprogress（）似乎永远不会互相均衡，因此更改if语句是有效的。

展开查看全部
赞(0）分享  回复(0）举报  2021-07-06
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com