java - (android) 启动我的应用程序时出现错误 java.lang.IllegalStateException

coder 2023-12-23 原文

我想写一个简单的可视化音乐播放器(扫描/sdcard/Music，添加到播放列表，播放和可视化)/
但是当我启动应用程序时，我有一个错误 Cannot start activity (ru.vspr.MyMediaPlayerActivity) java.lang.IllegalStateException我该如何解决？

源代码:http://www.mediafire.com/download/y1paremphr57mbz/MyMediaPlayer.zip

日志:

    07-24 13:20:01.023 E/AndroidRuntime(22997): FATAL EXCEPTION: main
07-24 13:20:01.023 E/AndroidRuntime(22997): java.lang.RuntimeException: Unable to start activity ComponentInfo{ru.vspr/ru.vspr.MyMediaPlayerActivity}: java.lang.IllegalStateException
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:1956)
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:1981)
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.app.ActivityThread.access$600(ActivityThread.java:123)
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1147)
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.os.Handler.dispatchMessage(Handler.java:99)
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.os.Looper.loop(Looper.java:137)
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.app.ActivityThread.main(ActivityThread.java:4424)
07-24 13:20:01.023 E/AndroidRuntime(22997): at java.lang.reflect.Method.invokeNative(Native Method)
07-24 13:20:01.023 E/AndroidRuntime(22997): at java.lang.reflect.Method.invoke(Method.java:511)
07-24 13:20:01.023 E/AndroidRuntime(22997): at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:784)
07-24 13:20:01.023 E/AndroidRuntime(22997): at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:551)
07-24 13:20:01.023 E/AndroidRuntime(22997): at dalvik.system.NativeStart.main(Native Method)
07-24 13:20:01.023 E/AndroidRuntime(22997): Caused by: java.lang.IllegalStateException
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.media.MediaPlayer._reset(Native Method)
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.media.MediaPlayer.reset(MediaPlayer.java:1218)
07-24 13:20:01.023 E/AndroidRuntime(22997): at ru.vspr.MyMediaPlayerActivity.loadMusic(MyMediaPlayerActivity.java:156)
07-24 13:20:01.023 E/AndroidRuntime(22997): at ru.vspr.MyMediaPlayerActivity.loadTrack(MyMediaPlayerActivity.java:147)
07-24 13:20:01.023 E/AndroidRuntime(22997): at ru.vspr.MyMediaPlayerActivity.initialize(MyMediaPlayerActivity.java:100)
07-24 13:20:01.023 E/AndroidRuntime(22997): at ru.vspr.MyMediaPlayerActivity.onCreate(MyMediaPlayerActivity.java:58)
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.app.Activity.performCreate(Activity.java:4492)
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1049)
07-24 13:20:01.023 E/AndroidRuntime(22997): at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:1920)
07-24 13:20:01.023 E/AndroidRuntime(22997): ... 11 more

package ru.vspr;

import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import android.app.Activity;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.content.res.AssetManager;
import android.graphics.drawable.Drawable;
import android.media.audiofx.Visualizer;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.os.Bundle;
import android.os.Environment;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.Toast;
import android.util.Log;

public class MyMediaPlayerActivity extends Activity implements OnCompletionListener {
    WakeLock wakeLock;
    private static final String[] EXTENSIONS = { ".mp3", ".wav", ".ogg" }; //Р’РѕСЃРїСЂРѕРёР·РІРѕРґРёРјС‹Рµ С„РѕСЂРјР°С‚С‹
    List<String> trackNames; //РќР°Р·РІР°РЅРёСЏ РІРѕСЃРїСЂРѕРёР·РІРѕРґРёРјС‹С… С‚СЂРµРєРѕРІ
    List<String> trackArtworks; //РћР±Р»РѕР¶РєРё РІРѕСЃРїСЂРѕРёР·РІРѕРґРёРјС‹С… С‚СЂРµРєРѕРІ
    File path; //Р”РёСЂРµРєС‚РѕСЂРёСЏ, РѕС‚РєСѓРґР° Р±СѓРґРµС‚ Р·Р°РіСЂСѓР¶РµРЅР° РјСѓР·С‹РєР°
    File path2; //Р”РёСЂРµРєС‚РѕСЂРёСЏ, РѕС‚РєСѓРґР° Р±СѓРґСѓС‚ Р·Р°РіСЂСѓР¶РµРЅС‹ РѕР±Р»РѕР¶РєРё С‚СЂРµРєРѕРІ
    Button btnPlay; //РС‚Р° РєРЅРѕРїРєР° Р±СѓРґРµС‚ РјРµРЅСЏС‚СЊ СЃРІРѕС‘ РёР·РѕР±СЂР°Р¶РµРЅРёРµ РїСЂРё РЅР°Р¶Р°С‚РёРё
    Random random; //РСЃРїРѕР»СЊР·РѕРІР°РЅРѕ РґР»СЏ СЃР»СѓС‡Р°Р№РЅРѕРіРѕ РІРѕСЃРїСЂРѕРёР·РІРµРґРµРЅРёСЏ
    boolean shuffle; //РЎР»СѓС‡Р°Р№РЅРѕРµ РІРѕСЃРїСЂРѕРёР·РІРµРґРµРЅРёРµ РІРєР»СЋС‡РµРЅРѕ?
    boolean isTuning; 
    int currentTrack; //РРЅРґРµРєСЃ С‚РµРєСѓС‰РµРіРѕ С‚СЂРµРєР°
    MediaPlayer mediaPlayer; //РџР»РµРµСЂ
    Visualizer mVisualizer; //Р’РёР·СѓР°Р»РёР·Р°С‚РѕСЂ РґР»СЏ РЅРµРіРѕ
    VisualizerView mVisualizerView; //View РґР»СЏ РІРёР·СѓР°Р»РёР·Р°С‚РѕСЂР°

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        setVolumeControlStream(AudioManager.STREAM_MUSIC);
//      PowerManager powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
//      wakeLock = powerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, "Powered by YOBA Engine");
        setContentView(R.layout.main); 
        initialize();
    }

    @Override
    public void onResume(){
        super.onResume();
        wakeLock.acquire();
    }

    @Override
    public void onPause(){
        super.onPause();
        wakeLock.release();
        if(mediaPlayer != null){
            if(isPlaying()){
                pause();
                isTuning = false;
                btnPlay.setBackgroundResource(R.drawable.play);
            }
            if(isFinishing()){
                dispose();
                finish();
            }
        } else{
            if(isFinishing()){
                finish();
            }
        }
    }

    private void initialize(){
        btnPlay = (Button) findViewById(R.id.btnPlay);
        btnPlay.setBackgroundResource(R.drawable.play);
        trackNames = new ArrayList<String>();
        trackArtworks = new ArrayList<String>();
        currentTrack = 0;
        shuffle = false;
        isTuning = false;
        random = new Random();
        mediaPlayer = new MediaPlayer();

        addTracks(getTracks());
        loadTrack();
    }

    //Generate a String Array that represents all of the files found
    private String[] getTracks(){
            if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED) 
                    || Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED_READ_ONLY)){
                path = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MUSIC);
                path2 = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
                String[] temp = path.list();
                return temp;
            } else{
                Toast.makeText(getBaseContext(), "SD Card is either mounted elsewhere or is unusable", Toast.LENGTH_LONG).show();
            }
        return null;
    }

    //Adds the playable files to the trackNames List
    private void addTracks(String[] temp){
        if(temp != null){
            for(int i = 0; i < temp.length; i++){
                //Only accept files that have one of the extensions in the EXTENSIONS array
                if(trackChecker(temp[i])){
                    trackNames.add(temp[i]);
                    trackArtworks.add(temp[i].substring(0, temp[i].length()-4));
                }
            }
            Toast.makeText(getBaseContext(), "Loaded " + Integer.toString(trackNames.size()) + " Tracks", Toast.LENGTH_SHORT).show();
        }
    }

    //Checks to make sure that the track to be loaded has a correct extenson
    private boolean trackChecker(String trackToTest){
        for(int j = 0; j < EXTENSIONS.length; j++){
            if(trackToTest.contains(EXTENSIONS[j])){
                return true;
            }
        }
        return false;
    }

    //Loads the track by calling loadMusic
    private void loadTrack(){
        if(mediaPlayer != null){
            dispose();
        }
        if(trackNames.size() > 0){
            loadMusic();
        }
    }

    //loads a Music instance using either a built in asset or an external resource
    private void loadMusic(){
            try{
                FileInputStream fis = new FileInputStream(new File(path, trackNames.get(currentTrack)));
                FileDescriptor fileDescriptor = fis.getFD();
                mediaPlayer.setDataSource(fileDescriptor);
                mediaPlayer.prepare();
                mediaPlayer.setOnCompletionListener(this);              
//              setupVisualizerFxAndUI();               
            } catch(IOException e){
                e.printStackTrace();
                Toast.makeText(getBaseContext(), "Error Loading " + trackNames.get(currentTrack), Toast.LENGTH_LONG).show();
            }
//          return null;
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu){
        super.onCreateOptionsMenu(menu);
        createMenu(menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item){
        switch(item.getItemId()){
        case 0:
            //Set Looping
            synchronized(this){
                if(isLooping()){
                    setLooping(false);
                    Toast.makeText(getBaseContext(), "Playing Tracks Sequentially", Toast.LENGTH_SHORT).show();
                } else{
                    setLooping(true);
                    Toast.makeText(getBaseContext(), "Looping " + trackNames.get(currentTrack), Toast.LENGTH_SHORT).show();
                }
            }
            return true;
        case 1:
            //Set Shuffle
            synchronized(this){
                if(shuffle){
                    setShuffle(false);
                } else{
                    setShuffle(true);
                }
            }
            return true;
        case 2:
            //Stop Music
            synchronized(this){
                switchTracks();
                btnPlay.setBackgroundResource(R.drawable.play);
            }
            return true;
        default:
            return false;
        }
    }

    private void createMenu(Menu menu){
        MenuItem miLooping = menu.add(0, 0, 0, "Looping");{
            miLooping.setIcon(R.drawable.looping);
        }
        MenuItem miShuffle = menu.add(0, 1, 1, "Shuffle");{
            miShuffle.setIcon(R.drawable.shuffle);
        }
        MenuItem miStop = menu.add(0, 2, 2, "Stop");{
            miStop.setIcon(R.drawable.stop);
        }
    }

    public void click(View view){
        int id = view.getId();
        switch(id){
        case R.id.btnPlay:
            synchronized(this){
                if(isTuning){
                    isTuning = false;
                    btnPlay.setBackgroundResource(R.drawable.play);
                    pause();
                } else{
                    isTuning = true;
                    btnPlay.setBackgroundResource(R.drawable.pause);
                    playTrack();
                }
            }
            return;
        case R.id.btnPrevious:
            setTrack(0);
            loadTrack();
            playTrack();
            return;
        case R.id.btnNext:
            setTrack(1);
            loadTrack();
            playTrack();
            return;
        default:
            return;
        }
    }

    private void setTrack(int direction){
        if(direction == 0){
            currentTrack--;
            if(currentTrack < 0){
                currentTrack = trackNames.size()-1;
            }
        } else if(direction == 1){
            currentTrack++;
            if(currentTrack > trackNames.size()-1){
                currentTrack = 0;
            }
        }
        if(shuffle){
            int temp = random.nextInt(trackNames.size());
            while(true){
                if(temp != currentTrack){
                    currentTrack = temp;
                    break;
                }
                temp++;
                if(temp > trackNames.size()-1){
                    temp = 0;
                }
            }
        }
    }

    //Plays the Track
    private void playTrack(){
        if(isTuning && mediaPlayer != null){
            play();
            Toast.makeText(getBaseContext(), "Playing " + trackNames.get(currentTrack).substring(0, trackNames.get(currentTrack).length()-4), Toast.LENGTH_SHORT).show();
        }
    }

    //Simply sets shuffle to isShuffle and then displays a message for confirmation
    private void setShuffle(boolean isShuffle) {
        shuffle = isShuffle;
        if(shuffle){
            Toast.makeText(getBaseContext(), "Shuffle On", Toast.LENGTH_SHORT).show();
        } else{
            Toast.makeText(getBaseContext(), "Shuffle Off", Toast.LENGTH_SHORT).show();
        }
    }
    public void onCompletion(MediaPlayer mediaPlayer) {
        synchronized(this){

        }
    }

    public void play() {
        if(mediaPlayer.isPlaying()){
            return;
        }
        try{
            synchronized(this){
                mediaPlayer.start();
            }
        } catch(IllegalStateException ex){
            ex.printStackTrace();
    }
    }

    public void stop() {
        mediaPlayer.stop();
        synchronized(this){

        }
    }

    public void switchTracks(){
        mediaPlayer.seekTo(0);
        mediaPlayer.pause();
    }

    public void pause() {
        mediaPlayer.pause();
    }

    public boolean isPlaying() {
        return mediaPlayer.isPlaying();
    }

    public boolean isLooping() {
        return mediaPlayer.isLooping();
    }

    public void setLooping(boolean isLooping) {
        mediaPlayer.setLooping(isLooping);
    }

    public void setVolume(float volumeLeft, float volumeRight) {
        mediaPlayer.setVolume(volumeLeft, volumeRight);
    }

    public void dispose() {
        if(mediaPlayer.isPlaying()){
            stop();
        }
        mediaPlayer.release();
    }

    public void setupVisualizerFxAndUI() {
                mVisualizerView = new VisualizerView(this);
                mVisualizerView = (VisualizerView) findViewById(R.id.visualizerView);
                mVisualizer = new Visualizer(mediaPlayer.getAudioSessionId());
                mVisualizer.setCaptureSize(Visualizer.getCaptureSizeRange()[1]);
                mVisualizer.setDataCaptureListener(new Visualizer.OnDataCaptureListener() {
                        public void onWaveFormDataCapture(Visualizer visualizer, byte[] bytes,
                                                          int samplingRate) {
                            mVisualizerView.updateVisualizer(bytes);
                        }

                        public void onFftDataCapture(Visualizer visualizer, byte[] bytes, int samplingRate) {}
                    }, Visualizer.getMaxCaptureRate() / 1, true, false);
    }

}

附言在收到此错误之前，当我按下“播放”按钮时，有声音，但没有可视化。有没有办法来解决这个问题？

P.P.S 对不起我的英语，拜托

最佳答案

java.lang.IllegalStateException

在 VM 未处于正确状态时尝试执行操作时引发。

http://developer.android.com/reference/java/lang/IllegalStateException.html

07-24 12:49:27.054 E/AndroidRuntime(21733): Caused by: java.lang.IllegalStateException 07-24 12:49:27.054 E/AndroidRuntime(21733): at android.media.MediaPlayer.setDataSource(Native Method) 07-24 12:49:27.054 E/AndroidRuntime(21733): at android.media.MediaPlayer.setDataSource(MediaPlayer.java:889)

你应该调用 reset() 让它回到空闲状态。只有这样你才能调用 setDataSource()

编辑:

您应该将其余代码放入 onCompletion

public void onCompletion(MediaPlayer mediaPlayer) {

        try {

            mediaPlayer.reset();
            mediaPlayer.setDataSource(path.getAbsolutePath());

            mediaPlayer.prepare();

            mediaPlayer.setOnCompletionListener(this);

            mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalStateException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

关于java - (android) 启动我的应用程序时出现错误 java.lang.IllegalStateException，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17829150/

时出 IllegalStateException android AndroidRuntime mediaPlayer java

有关java - (android) 启动我的应用程序时出现错误 java.lang.IllegalStateException的更多相关文章

ruby - 在 Ruby 程序执行时阻止 Windows 7 PC 进入休眠状态 - 2
我需要在客户计算机上运行Ruby应用程序。通常需要几天才能完成(复制大备份文件)。问题是如果启用sleep，它会中断应用程序。否则，计算机将持续运行数周，直到我下次访问为止。有什么方法可以防止执行期间休眠并让Windows在执行后休眠吗？欢迎任何疯狂的想法;-) 最佳答案 Here建议使用SetThreadExecutionStateWinAPI函数，使应用程序能够通知系统它正在使用中，从而防止系统在应用程序运行时进入休眠状态或关闭显示。像这样的东西:require'Win32API'ES_AWAYMODE_REQUIRED=0x0
ruby - 将差异补丁应用于字符串/文件 - 2
对于具有离线功能的智能手机应用程序，我正在为Xml文件创建单向文本同步。我希望我的服务器将增量/差异(例如GNU差异补丁)发送到目标设备。这是计划:Time=0Server:hasversion_1ofXmlfile(~800kiB)Client:hasversion_1ofXmlfile(~800kiB)Time=1Server:hasversion_1andversion_2ofXmlfile(each~800kiB)computesdeltaoftheseversions(=patch)(~10kiB)sendspatchtoClient(~10kiBtransferred)Cl
ruby - ECONNRESET (Whois::ConnectionError) - 尝试在 Ruby 中查询 Whois 时出错 - 2
我正在用Ruby编写一个简单的程序来检查域列表是否被占用。基本上它循环遍历列表，并使用以下函数进行检查。require'rubygems'require'whois'defcheck_domain(domain)c=Whois::Client.newc.query("google.com").available?end程序不断出错(即使我在google.com中进行硬编码)，并打印以下消息。鉴于该程序非常简单，我已经没有什么想法了-有什么建议吗？/Library/Ruby/Gems/1.8/gems/whois-2.0.2/lib/whois/server/adapters/base.
ruby - 在 64 位 Snow Leopard 上使用 rvm、postgres 9.0、ruby 1.9.2-p136 安装 pg gem 时出现问题 - 2
我想为Heroku构建一个Rails3应用程序。他们使用Postgres作为他们的数据库，所以我通过MacPorts安装了postgres9.0。现在我需要一个postgresgem并且共识是出于性能原因你想要pggem。但是我对我得到的错误感到非常困惑当我尝试在rvm下通过geminstall安装pg时。我已经非常明确地指定了所有postgres目录的位置可以找到但仍然无法完成安装:$envARCHFLAGS='-archx86_64'geminstallpg--\--with-pg-config=/opt/local/var/db/postgresql90/defaultdb/po
ruby - 如何指定 Rack 处理程序 - 2
Rackup通过Rack的默认处理程序成功运行任何Rack应用程序。例如:classRackAppdefcall(environment)['200',{'Content-Type'=>'text/html'},["Helloworld"]]endendrunRackApp.new但是当最后一行更改为使用Rack的内置CGI处理程序时，rackup给出“NoMethodErrorat/undefinedmethod`call'fornil:NilClass”:Rack::Handler::CGI.runRackApp.newRack的其他内置处理程序也提出了同样的反对意见。例如Rack
ruby - 在 Ruby 中编写命令行实用程序 - 2
我想用ruby编写一个小的命令行实用程序并将其作为gem分发。我知道安装后，Guard、Sass和Thor等某些gem可以从命令行自行运行。为了让gem像二进制文件一样可用，我需要在我的gemspec中指定什么。最佳答案 Gem::Specification.newdo|s|...s.executable='name_of_executable'...endhttp://docs.rubygems.org/read/chapter/20 关于ruby-在Ruby中编写命令行实用程序
ruby-on-rails - Rails 应用程序之间的通信 - 2
我构建了两个需要相互通信和发送文件的Rails应用程序。例如，一个Rails应用程序会发送请求以查看其他应用程序数据库中的表。然后另一个应用程序将呈现该表的json并将其发回。我还希望一个应用程序将存储在其公共(public)目录中的文本文件发送到另一个应用程序的公共(public)目录。我从来没有做过这样的事情，所以我什至不知道从哪里开始。任何帮助，将不胜感激。谢谢! 最佳答案无论Rails是什么，几乎所有Web应用程序都有您的要求，大多数现代Web应用程序都需要相互通信。但是有一个小小的理解需要你坚持下去，网站不应直接访问彼此
ruby - 无法运行 Rails 2.x 应用程序 - 2
我尝试运行2.x应用程序。我使用rvm并为此应用程序设置其他版本的ruby:$rvmuseree-1.8.7-head我尝试运行服务器，然后出现很多错误:$script/serverNOTE:Gem.source_indexisdeprecated,useSpecification.Itwillberemovedonorafter2011-11-01.Gem.source_indexcalledfrom/Users/serg/rails_projects_terminal/work_proj/spohelp/config/../vendor/rails/railties/lib/r
ruby-on-rails - Rails 应用程序中的 Rails : How are you using application_controller. rb 是新手吗？ - 2
刚入门rails，开始慢慢理解。有人可以解释或给我一些关于在application_controller中编码的好处或时间和原因的想法吗？有哪些用例。您如何为Rails应用程序使用应用程序Controller？我不想在那里放太多代码，因为据我了解，每个请求都会调用此Controller。这是真的？最佳答案 ApplicationController实际上是您应用程序中的每个其他Controller都将从中继承的类(尽管这不是强制性的)。我同意不要用太多代码弄乱它并保持干净整洁的态度，尽管在某些情况下ApplicationContr
java - 等价于 Java 中的 Ruby Hash - 2
我真的很习惯使用Ruby编写以下代码:my_hash={}my_hash['test']=1Java中对应的数据结构是什么？最佳答案 HashMapmap=newHashMap();map.put("test",1);我假设？关于java-等价于Java中的RubyHash，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.com/questions/22737685/

java - (android) 启动我的应用程序时出现错误 java.lang.IllegalStateException

有关java - (android) 启动我的应用程序时出现错误 java.lang.IllegalStateException的更多相关文章

随机推荐