android mediaRecorder.setAudioSource fehlgeschlagen

Ich habe Android G1 Firmware 1.6, ich versuche, Sprache aus der App mit dem folgenden Code aufzuzeichnen.

MediaRecorder recorder = neuer MediaRecorder ();
 recorder.setAudioSource (MediaRecorder.AudioSource.MIC);
 recorder.setOutputFormat (MediaRecorder.OutputFormat.THREE_GPP);
 recorder.setAudioEncoder (MediaRecorder.AudioEncoder.AMR_NB);
 recorder.setOutputFile (PATH_NAME);
 recorder.prepare ();
 recorder.start ();  

meine manifest.xml hat:

<Verwendungsberechtigung android: name = "android.permission.RECORD_AUDIO" />

Ich habe:

09-23 14: 41: 05.531: ERROR / AndroidRuntime (1718): Nicht erfasster Handler: Thread-Haupt wird aufgrund einer nicht erfassten Ausnahme beendet
09-23 14: 41: 05.551: ERROR / AndroidRuntime (1718): java.lang.RuntimeException: setAudioSource fehlgeschlagen.
09-23 14: 41: 05.551: ERROR / AndroidRuntime (1718): at android.media.MediaRecorder.setAudioSource (native Methode)

Wie nehme ich die Stimme richtig auf?

Öffnen Sie " AndroidManifest.xml" ->

hinzufügen

<uses-permission android:name="android.permission.RECORD_AUDIO" />

Ich weiß, dass dies eine sehr alte Frage ist, aber in Android Marshmallow müssen Sie auf "Einstellungen> Apps> Ihre App> Berechtigungen" klicken und die Mikrofonberechtigung aktivieren.

Wenn Sie mit Android M arbeiten, müssen Sie beim ersten Ausführen Berechtigungen zum Aufzeichnen von Audio anfordern. Fragen Sie dazu den Benutzer, ob Sie beim Starten der Anwendung Audio aufnehmen können:

private static final int MY_PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE = 29;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    if (mContext.checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
        requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.RECORD_AUDIO},
                MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE);
    } else {
        Log.d("Home", "Already granted access");
        initializeView(v);
    }
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) {
    switch (requestCode) {
        case MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE: {
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Log.d("Home", "Permission Granted");
                initializeView(v);
            } else {
                Log.d("Home", "Permission Failed");
                Toast.makeText(getActivity().getBaseContext(), "You must allow permission record audio to your mobile device.", Toast.LENGTH_SHORT).show();
                getActivity().finish();
            }
        }
        // Add additional cases for other permissions you may have asked for
    }
}

Überprüfen Sie für API 23+ die Berechtigung für Audioaufzeichnungen sowohl in Manifest.xml <uses-permission android:name="android.permission.RECORD_AUDIO" />als auch in Java Code

if (ActivityCompat.checkSelfPermission(cnt, Manifest.permission.RECORD_AUDIO)
            != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(cnt, arrayOf(
                Manifest.permission.RECORD_AUDIO
        ),0)
        return
    }

WICHTIG - In den letzten Stunden habe ich versucht herauszufinden, wie überprüft werden kann, ob das MIC von einer anderen Anwendung erfasst wird oder nicht. Ich habe festgestellt, dass, wenn 2 Anwendungsadressen gleichzeitig an MediaRecorder gesendet werden, eine RuntimeException ausgelöst wird und Sie das Mikrofon nicht verwenden können, es sei denn, Sie starten Ihr Gerät neu (!!). Ich weiß nicht, ob es die beste Lösung ist, aber es hat bei mir funktioniert. Vielleicht spart es einigen von Ihnen eines Tages ein paar Stunden.

private void validateMicAvailability() throws MicUnaccessibleException {
    AudioRecord recorder =
        new AudioRecord(AudioSource.MIC, 44100,
                AudioFormat.CHANNEL_IN_MONO,
                AudioFormat.ENCODING_DEFAULT, 44100);
    try{
        if(recorder.getRecordingState() != AudioRecord.RECORDSTATE_STOPPED ){
            throw new MicUnaccessibleException("Mic didn't successfully initialized");
        }

        recorder.startRecording();
        if(recorder.getRecordingState() != AudioRecord.RECORDSTATE_RECORDING){
            recorder.stop();
            throw new MicUnaccessibleException("Mic is in use and can't be accessed");
        }
        recorder.stop();
    } finally{
        recorder.release();
        recorder = null;
    }
}

Ich hatte genau dieses Problem, das löste es für mich:

Gehen Sie auf dem Gerät, das Sie zum Debuggen verwenden, zu Einstellungen -> Apps -> {Ihre App}. Stellen Sie dann sicher, dass alle Berechtigungen der App (in diesem Fall Audioaufzeichnung und Schreiben von externem Speicher) zulässig sind.

Wenn Sie eine App nicht über den Google Play Store installieren, werden Sie offenbar nicht aufgefordert, Berechtigungen zu erteilen. Auf einigen Telefonen werden Ihrer Debugging-App keine Berechtigungen erteilt.

Überprüfen Sie dies auch dann, wenn einige Berechtigungen in der Manifestdatei erkannt werden (z. B. Internetzugang), da für mich einige funktionierten und andere automatisch blockiert wurden.

Hoffe das hilft.

Für API 23+ müssen Sie die Lese- / Schreibberechtigungen anfordern, auch wenn sie bereits in Ihrem Manifest enthalten sind.

// Check for permissions
int permission = ActivityCompat.checkSelfPermission(getActivity(), Manifest.permission.WRITE_EXTERNAL_STORAGE);

// If we don't have permissions, ask user for permissions
if (permission != PackageManager.PERMISSION_GRANTED) {
    String[] PERMISSIONS_STORAGE = {
        android.Manifest.permission.READ_EXTERNAL_STORAGE,
        android.Manifest.permission.WRITE_EXTERNAL_STORAGE
    }; 
    int REQUEST_EXTERNAL_STORAGE = 1;

    ActivityCompat.requestPermissions(
        getActivity(),
        PERMISSIONS_STORAGE,
        REQUEST_EXTERNAL_STORAGE
    );
}

Bitte fordern Sie die Manifest.permission.RECORD_AUDIOErlaubnis dynamisch für Marshmallow und höher an.

Das sieht richtig aus. Stellen Sie sicher, dass andere Anwendungen das MIC noch nicht verwenden. Starten Sie das Telefon möglicherweise neu und versuchen Sie es erneut.

Dieser Code hat bei mir funktioniert

 mRecorder = new MediaRecorder();
 mRecorder.reset();
 mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);

Als Cyanogenmod-User musste ich

1. Stellen Sie sicher, dass die Berechtigungen im Manifest definiert sind (android-studio)
2. Stellen Sie sicher, dass der Datenschutzbeauftragte der App den Zugriff auf das Mikrofon (auf dem Gerät) gestattet hat.
3. Stellen Sie sicher, dass das Android-System die Berechtigungen unter Settings-> Apps-> Wählen Sie Ihre App -> Permissions-> Alle Berechtigungen überprüfen (sollten die vom Manifest angeforderten sein) (auf dem Gerät) festgelegt hat.

Danach funktionierte die Neukodierung für mich.

Probieren Sie diesen Code aus, er hilft Ihnen sehr und ist verständlich .....

public class MainActivity extends Activity {

    MediaRecorder mRecorder;
    MediaPlayer mediaPlayer;
    Button start, stop, play,stop_play;
    String FileName="";
    File outfile ;

    public static final int request_code = 1000;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        start=(Button)findViewById(R.id.btn_start_main);
        stop=(Button)findViewById(R.id.btn_stop_main);
        play=(Button)findViewById(R.id.btn_play_main);
        stop_play=(Button)findViewById(R.id.btn_playstop_main);

        if (checkPermissionFromDevice()){

            start.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    FileName= Environment.getExternalStorageDirectory().getAbsolutePath()+"/"+
                            UUID.randomUUID()+"AudioFile.3gp";

                    SetupMediaRecorder();

                    try {
                        mRecorder.prepare();
                        mRecorder.start();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    start.setEnabled(false);
                    stop.setEnabled(true);
                    play.setEnabled(false);
                    stop_play.setEnabled(false);

                    Toast.makeText(getApplicationContext(),"recording....",Toast.LENGTH_SHORT).show();
                }
            });
            stop.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    mRecorder.stop();
                    play.setEnabled(true);
                    start.setEnabled(true);
                    stop.setEnabled(false);
                    stop_play.setEnabled(false);
                    Toast.makeText(getApplicationContext(),"recording stoped....",Toast.LENGTH_SHORT).show();
                }
            });
            play.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    mediaPlayer=new MediaPlayer();
                    try {
                        mediaPlayer.setDataSource(FileName);
                        mediaPlayer.prepare();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    mediaPlayer.start();
                    start.setEnabled(false);
                    stop.setEnabled(false);
                    play.setEnabled(false);
                    stop_play.setEnabled(true);
                    Toast.makeText(getApplicationContext(),"playing..",Toast.LENGTH_SHORT).show();
                }
            });
            stop_play.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    mediaPlayer.stop();
                    SetupMediaRecorder();
                    start.setEnabled(true);
                    stop_play.setEnabled(false);
                    play.setEnabled(false);
                }
            });

        }
        else {

            requestPermissionFromDevice();
        }





    }

    private void SetupMediaRecorder() {
        mRecorder=new MediaRecorder();
        mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
        mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
        mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
        mRecorder.setOutputFile(FileName);
    }

    private void requestPermissionFromDevice() {
        ActivityCompat.requestPermissions(this,new String[]{
                Manifest.permission.WRITE_EXTERNAL_STORAGE,
                Manifest.permission.RECORD_AUDIO},
                request_code);
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode){
            case request_code:
            {
                if (grantResults.length>0 && grantResults[0] == PackageManager.PERMISSION_GRANTED ){
                    Toast.makeText(getApplicationContext(),"permission granted...",Toast.LENGTH_SHORT).show();
                }
                else {
                    Toast.makeText(getApplicationContext(),"permission denied...",Toast.LENGTH_SHORT).show();
                }
            }
                break;
        }
    }

    private boolean checkPermissionFromDevice() {
        int storage_permission= ContextCompat.checkSelfPermission(this,Manifest.permission.WRITE_EXTERNAL_STORAGE);
        int recorder_permssion=ContextCompat.checkSelfPermission(this,Manifest.permission.RECORD_AUDIO);
    return storage_permission == PackageManager.PERMISSION_GRANTED && recorder_permssion == PackageManager.PERMISSION_GRANTED;
    }
}

Ich habe es in einen anderen Thread verschoben. Funktioniert alles.

Hier ist ein Code:

new Thread(() -> {
    mediaRecorder.reset();
    mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
    mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
    mediaRecorder.setOutputFile("/audiorecordtest.3gp");
    mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
        try {
            mediaRecorder.prepare();
            mediaRecorder.start();
            //do something here
            mediaRecorder.stop();
        } catch (IOException e) {
            e.printStackTrace();
            Log.d("Audio","unable to prepare");
        }

}).start();

Mein Vorschlag mag dumm aussehen, aber er hat bei mir funktioniert :)

Versuchen Sie, die Berechtigung als verschachteltes Tag zu erteilen. Ich glaube, es gibt irgendwo ein XML-Analyseproblem mit der Android-Verpackungsbibliothek.

Stellen Sie sicher, dass das Android-System die Berechtigungen für das Gerät festgelegt hat. Diese sollten vom Manifest angefordert werden:

• unter Einstellungen -> Apps -> App auswählen -> Berechtigungen -> Alle Berechtigungen einchecken

Veränderung

<uses-permission android:name="android.permission.RECORD_AUDIO" />

zu

<uses-permission android:name="android.permission.RECORD_AUDIO" ></uses-permission>

Hat für mich gearbeitet.