Android MediaRecorder.setAudioSource विफल हुआ




media-player voice (10)

मेरे पास Android G1 फर्मवेयर 1.6 है, मैं फॉलो कोड के साथ ऐप से आवाज रिकॉर्ड करने की कोशिश कर रहा हूं।

MediaRecorder recorder = new 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();  

मेरा मेनिफ़ेस्ट। xml है:

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

मुझे मिला:

09-23 14:41:05.531: ERROR/AndroidRuntime(1718): Uncaught handler: thread main exiting due to uncaught exception
09-23 14:41:05.551: ERROR/AndroidRuntime(1718): java.lang.RuntimeException: setAudioSource failed.
09-23 14:41:05.551: ERROR/AndroidRuntime(1718):     at android.media.MediaRecorder.setAudioSource(Native Method)

मैं ठीक से आवाज कैसे रिकॉर्ड करूं?


API 23+ के लिए, Manifest.xml दोनों में ऑडियो रिकॉर्ड अनुमति की जांच करें <uses-permission android:name="android.permission.RECORD_AUDIO" /> और जावा कोड में

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

इस कोड की कोशिश करो यह आपको बहुत मदद करता है और इसके समझने योग्य .....

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;
    }
}

एक CyanogenMod- उपयोगकर्ता के रूप में मुझे करना था

  1. सुनिश्चित करें कि अनुमतियाँ प्रकट (एंड्रॉइड-स्टूडियो) में परिभाषित हैं
  2. सुनिश्चित करें कि गोपनीयता गार्ड ने एप्लिकेशन को माइक्रोफ़ोन (डिवाइस पर) तक पहुंचने की अनुमति दी है
  3. सुनिश्चित करें कि एंड्रॉइड सिस्टम ने Settings तहत अनुमतियों को सेट किया था -> Apps -> अपने ऐप का चयन करें -> Permissions -> सभी अनुमतियों की जांच करें (प्रकट द्वारा अनुरोधित होना चाहिए) (डिवाइस पर)

उसके बाद रिकोडिंग ने मेरे लिए काम किया।


एपीआई 23+ के लिए आपको पढ़ने / लिखने की अनुमति का अनुरोध करने की आवश्यकता है, भले ही वे पहले से ही आपके घोषणापत्र में हों।

// 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
    );
}

जो सही लगता है। सुनिश्चित करें कि अन्य अन्य अनुप्रयोग पहले से ही एमआईसी का उपयोग नहीं कर रहे हैं। शायद फ़ोन को पुनः आरंभ करें और पुनः प्रयास करें।


परिवर्तन

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

सेवा मेरे

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

मेरे लिए काम किया।


मुझे पता है कि यह एक बहुत पुराना सवाल है, लेकिन एंड्रॉइड मार्शमैलो में आपको "सेटिंग> ऐप्स> आपका ऐप> अनुमतियां" पर जाना होगा और माइक्रोफोन की अनुमति लेनी होगी।


मुझे यह सटीक समस्या थी, इसने मेरे लिए इसे हल किया:

डिबगिंग के लिए आप जिस डिवाइस का उपयोग करते हैं, वह सेटिंग -> ऐप्स -> {आपके ऐप} पर जाता है। फिर सुनिश्चित करें कि सभी एप्लिकेशन की अनुमति (इस मामले में ऑडियो रिकॉर्डिंग और राइटिंग एक्सटर्नल स्टोरेज) की अनुमति है।

स्पष्ट रूप से Google Play Store के माध्यम से ऐप इंस्टॉल नहीं करने पर आपको अनुमति देने के लिए नहीं कहा जाता है और कुछ फोन पर आपके डिबगिंग ऐप के परिणामस्वरूप कुछ अनुमतियाँ नहीं मिलेंगी।

भले ही मेरे लिए कुछ काम किए गए और कुछ अपने आप ब्लॉक हो गए, भले ही मैनिफ़ेस्ट फ़ाइल में कुछ अनुमतियाँ पहचानी जा रही हों (जैसे कि इंटरनेट एक्सेस)।

उम्मीद है की यह मदद करेगा।


मैंने इसे दूसरे धागे में स्थानांतरित कर दिया। सब कुछ काम करता है।

यहाँ एक कोड है:

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();

यदि आप एंड्रॉइड एम पर चल रहे हैं, तो आपको पहले रन पर ऑडियो रिकॉर्ड करने के लिए अनुमतियों का अनुरोध करना होगा। इसे पूरा करने के लिए, उपयोगकर्ता से पूछें कि क्या आप एप्लिकेशन शुरू होने पर ऑडियो रिकॉर्ड कर सकते हैं:

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
    }
}




gfx