在 Android 上录制电话答案

【问题标题】：Recording phone calls on Android在 Android 上录制电话
【发布时间】：2010-10-14 04:01:19
【问题描述】：

我正在尝试使用 mic 编写此代码但无法正常工作的记录拨出电话，我测试了简单音频记录的代码它工作正常，我不确定何时开始媒体记录我在广播接收器中开始可能有问题在那里。

这里 Audiorecoder 是另一个类，在我实现 MediaRecoder 的地方创建

public void onReceive(Context context, Intent intent) {
        // TODO Auto-generated method stub

        audrec = new AudioRecorder("newcall");
        this.context = context;
        if (intent.getAction().equalsIgnoreCase(Intent.ACTION_DIAL)) 
        {
            try {
                audrec.start();
                recordstarted = 1;
                telManager= (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);

            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        final PhoneStateListener phoneListener = new PhoneStateListener()
        {
            @Override
            public void onCallStateChanged(final int state, final String incomingNumber)
            {
                getTelephonyOverview(telManager);
            }
        };

        telManager.listen(phoneListener, PhoneStateListener.LISTEN_CALL_STATE);

    }
    public void getTelephonyOverview(final TelephonyManager telManager)
    {
        int callState = telManager.getCallState();
        switch (callState)
        {
        case TelephonyManager.CALL_STATE_IDLE:
        {
            if (recordstarted==1)
            {
                try {
                    audrec.stop();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                recordstarted =0;
            }
            break;
        }
        case TelephonyManager.CALL_STATE_OFFHOOK:
        {
            try {
                audrec.start();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            recordstarted =1;
            break;
        }
        case TelephonyManager.CALL_STATE_RINGING:       
        {
            try {
                audrec.start();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            recordstarted =1;
            break;
        }
        }
    }

我正在尝试创建 3Gp 文件但不播放的另一个代码

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class androidrec extends Activity
{
   Button btn_start;
   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState) 
   {
      super.onCreate(savedInstanceState); setContentView(R.layout.main);
      btn_start = (Button) findViewById(R.id.btn_start);
      UpdateRecorderState();
      btn_start.setOnClickListener(new View.OnClickListener() 
      {
         public void onClick(View v) 
         {              
            //          Toast.makeText(getBaseContext(),"Please enter both phone number and message.", 
            //          Toast.LENGTH_SHORT).show();
            if(!SharedData._Started) { StartServicesAtStartUp.Start_CallRec(getBaseContext()); }
            else { StartServicesAtStartUp.Stop_CallRec(getBaseContext()); }
            UpdateRecorderState();
         }
      });        


   }

   private void UpdateRecorderState() 
   {
      if(SharedData._Started)
      {btn_start.setText("Stop Recording");}
      else
      {btn_start.setText("Start Recording");}
   }
}[/code]


import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import android.media.MediaRecorder;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import android.util.Log;

//import com.lumitrend.netlogger.Logger;

public class CallStateListener extends PhoneStateListener {
   public void onCallStateChanged(int state, String incomingNumber)
   {
      super.onCallStateChanged(state, incomingNumber);
      switch(state)
      {
      case TelephonyManager.CALL_STATE_IDLE:
         if(SharedData._Recording) 
         { Recorders_Stop(); }
         break;
      case TelephonyManager.CALL_STATE_RINGING:
         break;
      case TelephonyManager.CALL_STATE_OFFHOOK:
         String CallDate = SanityDate();
         String CallNum = SanityNum(incomingNumber);
         String RootDir = SharedData._Path ;  
         String CallDir = SharedData._Path + CallNum + "/" ;
         String CallFile = SharedData._Path +  CallNum + "/" + CallNum + CallDate ;
         if(!SharedData._Recording)
         {
            SharedData._Recording = true;
            String med_state = android.os.Environment.getExternalStorageState();
            if(!med_state.equals(android.os.Environment.MEDIA_MOUNTED))
            { break; }

            File directory = null;
            directory = new File(RootDir + "text.txt" ).getParentFile();
            if (!directory.exists() && !directory.mkdirs())
            { break; }

            directory = new File(CallDir + "text.txt" ).getParentFile();
            if (!directory.exists() && !directory.mkdirs())
            { break; }

            Recoders_Init(CallFile);
            Recorder_Prepare();
         }
         Log.v("DEBUG", TelephonyManager.CALL_STATE_OFFHOOK + " ITS.CallRecorder - Recording Started " + state);
         break;
      }
   }

   private String SanityDate() {
      SimpleDateFormat formatter = new SimpleDateFormat("yyMMdd-HHmmss");
      Date currentTime_1 = new Date();
      return formatter.format(currentTime_1);
   }

   private void Recorders_Stop() {
      try { 
         SharedData._recorder.stop(); SharedData._recorder.reset();
         //SharedData._recorder_down.stop(); SharedData._recorder_down.reset();
         //SharedData._recorder_up.stop();       SharedData._recorder_up.reset(); 
      }
      catch (IllegalStateException e) {}
      SharedData._Recording = false;
   }

   private void Recorder_Prepare() {
      try {
         SharedData._recorder.prepare(); SharedData._recorder.start(); 
         //SharedData._recorder_down.prepare(); SharedData._recorder_down.start(); 
         //SharedData._recorder_up.prepare(); SharedData._recorder_up.start(); 
      }
      catch (IllegalStateException e) { e.printStackTrace(); }
      catch (IOException e) { e.printStackTrace(); }
   }

   private void Recoders_Init(String path) {
      String _ext = ".3gp";
      int out_format = MediaRecorder.OutputFormat.THREE_GPP;

      SharedData._recorder.setAudioSource(SharedData._Rec_Type);
      SharedData._recorder.setOutputFormat(out_format);
      SharedData._recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
      SharedData._recorder.setOutputFile(path + "both" + _ext);

      /*
                SharedData._recorder_down.setAudioSource(MediaRecorder.AudioSource.VOICE_DOWNLINK);
                SharedData._recorder_down.setOutputFormat(out_format);
                SharedData._recorder_down.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
                SharedData._recorder_down.setOutputFile(path + "-down" + _ext);

                SharedData._recorder_up.setAudioSource(MediaRecorder.AudioSource.VOICE_UPLINK);
                SharedData._recorder_up.setOutputFormat(out_format);
                SharedData._recorder_up.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
                SharedData._recorder_up.setOutputFile(path  + "-up" + _ext);
       */

   }
   private String SanityNum(String numstr)
   {
      String out = "";
      for(char ch : numstr.toCharArray())
      {
         switch(ch)
         {
         case ' ': 
            break;
         case '~': 
            break;
         case '!': 
            break;
         case '@': 
            break;
         case '#': 
            break;
         case '$': 
            break;
         case '%': 
            break;
         case '^': 
            break;
         case '&': 
            break;
         case '*': 
            break;
         case '(': 
            break;
         case ')': 
            break;
         case '-': 
            break;
         case '_': 
            break;
         case '=': 
            break;
         case '|': 
            break;
         default:
            out = out + ch;
         }
      }
      return out;
   }
} 


import android.media.MediaRecorder;

final public class SharedData
{

   static int _Rec_Type = android.media.MediaRecorder.AudioSource.VOICE_CALL;


   static String _Path = android.os.Environment.getExternalStorageDirectory().getAbsolutePath() + "/ITS-CallRecorder/";
   static boolean _Started = false;
   static boolean _AutoStart = true;
   static boolean _Recording = false;

   static MediaRecorder _recorder = new MediaRecorder();
   static MediaRecorder _recorder_down = new MediaRecorder();
   static MediaRecorder _recorder_up = new MediaRecorder();

   SharedData() {    }
}

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import android.util.Log;
import android.widget.Toast;



public class StartServicesAtStartUp extends BroadcastReceiver
{
   public static Intent phoneStateListener;
   public void onReceive(Context context, Intent intent)
   {
      Log.d("DEBUG", "com.its.CallRecorder Initiated ...");
      Start_CallRec(context);
   }

   public static void Start_CallRec(Context context)
   {
      if(!SharedData._Started )
      {
         if(SharedData._AutoStart)
         {
            phoneStateListener = new Intent(context, CallStateListener.class);
            phoneStateListener.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            context.startService(phoneStateListener);
            Log.d("DEBUG", "com.its.CallRecorder Call Recorder Started ...");
            TelephonyManager tManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
            CallStateListener callStateListener = new CallStateListener();
            tManager.listen(callStateListener,PhoneStateListener.LISTEN_CALL_STATE);
            SharedData._Started = true;
            Toast.makeText(context," Call Recording Started ... ", Toast.LENGTH_SHORT).show();
         }       
      }
      else
      {
         Toast.makeText(context," Call Recording Already Active.. ", Toast.LENGTH_SHORT).show();
      }
   }

   public static void Stop_CallRec(Context context)
   {
      if(SharedData._Started )
      {
         context.stopService(phoneStateListener);
         Toast.makeText(context," Call Recording Stopped  ... ", Toast.LENGTH_SHORT).show();
         SharedData._Started = false;                    
      }
      else
      {
         Toast.makeText(context," Call Recording Already Stopped  ... ",  Toast.LENGTH_SHORT).show();
      }
   }

}

【问题讨论】：

"....... 3Gp 文件但没有播放.."，这是什么意思是你没有得到 3Gp 文件或者你得到它但它没有播放。
我正在获取 3gp 文件。我发现它总是创建 32kb 显示这意味着它没有记录空洞呼叫。
您的评论是正确的 - 这在整个 android 平台上是不可能的。现有的市场应用通过将电话放在免提电话中并从麦克风中拾取整个对话来工作。您无法直接访问音频通道，即使是操作系统级别的 root。
@ud_an 请告诉我，录制后我在哪里可以找到手机上的特定 3gp 文件？

标签： android

【解决方案1】：

您无法录制通话，因为固件不支持它。 xda-devs 有一个更好的答案，我从 android 的未决问题列表中获得：

语音流由基带处理器处理基带处理器，就是那个基带固件未设置为向应用程序提供流限制能力的处理器真正记录通话。安卓系统早就实现了API，但在这种情况下它什么也做不了。

由于基带固件关闭仅以二进制形式提供和提供，我怀疑这里的优秀黑客是否可以做任何事情。

有人找到了 HD2 的“治愈方法”，只是通过编辑注册表 - xda-developers.com/windows-mobile/two-way-in-call-recording-on-hd2-fixed/wo-way-in-call-recording-on-hd2-fixed/

【讨论】：

还有一个HTC Hero应用可以记录通话，不过一般安卓平台整体好像不行。
市场上有安卓应用程序可以双向记录，但存在一些问题，但它可以工作。经过几次更改后，我现在测试了我的应用程序，在 HTC G1 上录制未传入的呼出电话
@ud_an 这就是我的意思是您面临的问题是特定于固件的，而 Android 确实在设备上实现了 api 以支持语音流。有许多受支持的 d3 设备，例如三星 Galaxy 和许多其他设备。

【解决方案2】：

Android 上尚无法进行通话录音。看到这个feature request。

你可以通过麦克风录制你的声音，但你不能录制对方的声音。如果您只想录制语音，请使用 android.media.MediaRecorder.AudioSource.MIC

【讨论】：