Android 以编程方式获取通话期间的通话持续时间？

我正在创建一个应用程序，它可以访问电话状态，并将能够根据某些限制结束传出呼叫。我能够通过以下方式实现这一目标：

if (!intent.getAction().equals("android.intent.action.PHONE_STATE"))
                return;
            else
            {

               String time = finalprefs.getString("timedelay","0");
               System.out.println("TIME - "+time);
                number = intent.getStringExtra(TelephonyManager.EXTRA_INCOMING_NUMBER);
                WhitelistDAO whiteListDao = new WhitelistDAO(context);
                List<Whitelist> whiteList = whiteListDao.getAllWhitelist();
                if(number != null) {
                    number =  lastten(number);
                    Log.e("CALLED NUMBER", "NUM - " + number);
                    Log.e("BLOCKED NUMBER", "BLLACK - " + new Whitelist(number).toString());
                    // Check, whether this is a member of "Black listed" phone numbers stored in the database
                    if (whiteList.contains(new Whitelist(number))) {
                        Log.e("Call","Allowed");
                        Toast.makeText(getApplicationContext(),"Success",Toast.LENGTH_SHORT).show();
                    } else {
                        Toast.makeText(getApplicationContext(),"This call is not allowed by your administration! Contact Karthik",Toast.LENGTH_SHORT).show();
                        disconnectPhoneItelephony(context);

                        return;
                    }
                }

if（！intent.getAction（）.equals（“android.intent.action.PHONE_STATE”））
返回；
其他的
{
String time=finalprefs.getString（“timedelay”，“0”）；
System.out.println（“时间-”+时间）；
number=intent.getStringExtra（TelephonyManager.EXTRA\u传入\u编号）；
WhitelistDAO WhitelistDAO=新的WhitelistDAO（上下文）；
List whiteList=whiteListDao.getAllWhitelist（）；
如果（数字！=null）{
数字=最后十（数字）；
Log.e（“被叫号码”，“NUM-”+号码）；
Log.e（“阻止的编号”、“BLLACK-”+新的白名单（编号）.toString（））；
//检查，这是否是存储在数据库中的“黑名单”电话号码的成员
if（白名单.包含（新白名单（编号）））{
Log.e（“呼叫”、“允许”）；
Toast.makeText（getApplicationContext（），“Success”，Toast.LENGTH\u SHORT.show（）；
}否则{
Toast.makeText（getApplicationContext（），“您的管理不允许此调用！请与Karthik联系”，Toast.LENGTH_SHORT.show（）；
断开PhoneItelePhony（上下文）；
返回；
}
}

但是现在我想在连接10分钟后断开呼出电话的连接！我搜索了这个，但没有得到任何正确的解决方案！大多数信息都表明不可能在通话时获得通话持续时间！那么有解决方案吗

---

请帮助！

试试这段代码，我还为通话记录添加了权限

public class MainActivity extends AppCompatActivity {

private static final int REQUEST_PERMISSIONS_REQUEST_CODE = 1;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    if (!checkPermissions()) {
        requestPermissions();
    } else {

        getCallDetails();
    }

}

private void getCallDetails() {
    StringBuffer sb = new StringBuffer();
    Uri contacts = CallLog.Calls.CONTENT_URI;
    Cursor managedCursor = this.getContentResolver().query(contacts, null, null, null, null);
    int number = managedCursor.getColumnIndex(CallLog.Calls.NUMBER);
    int type = managedCursor.getColumnIndex(CallLog.Calls.TYPE);
    int date = managedCursor.getColumnIndex(CallLog.Calls.DATE);
    int duration = managedCursor.getColumnIndex(CallLog.Calls.DURATION);
    sb.append("Call Details :");
    while (managedCursor.moveToNext()) {

        HashMap rowDataCall = new HashMap<String, String>();

        String phNumber = managedCursor.getString(number);
        String callType = managedCursor.getString(type);
        String callDate = managedCursor.getString(date);
        String callDayTime = new Date(Long.valueOf(callDate)).toString();
        // long timestamp = convertDateToTimestamp(callDayTime);
        String callDuration = managedCursor.getString(duration);
        String dir = null;
        int dircode = Integer.parseInt(callType);
        switch (dircode) {
            case CallLog.Calls.OUTGOING_TYPE:
                dir = "OUTGOING";
                break;

            case CallLog.Calls.INCOMING_TYPE:
                dir = "INCOMING";
                break;

            case CallLog.Calls.MISSED_TYPE:
                dir = "MISSED";
                break;
        }
        sb.append("\nPhone Number:--- " + phNumber + " \nCall Type:--- " + dir + " \nCall Date:--- " + callDayTime + " \nCall duration in sec :--- " + callDuration);
        sb.append("\n----------------------------------");


    }
    managedCursor.close();
    System.out.println(sb);
}

/**
 * this method request to permission asked.
 */
private void requestPermissions() {
    boolean shouldProvideRationale =
            ActivityCompat.shouldShowRequestPermissionRationale(this,
                    Manifest.permission.READ_CALL_LOG);

    if (shouldProvideRationale) {
    } else {
        Log.i("Error", "Requesting permission");
        // previously and checked "Never ask again".
        ActivityCompat.requestPermissions(MainActivity.this,
                new String[]{Manifest.permission.READ_CALL_LOG},
                REQUEST_PERMISSIONS_REQUEST_CODE);
    }
}

/**
 * this method check permission and return current state of permission need.
 */
private boolean checkPermissions() {
    int permissionState = ActivityCompat.checkSelfPermission(this,
            Manifest.permission.READ_CALL_LOG);
    return permissionState == PackageManager.PERMISSION_GRANTED;
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if (requestCode == REQUEST_PERMISSIONS_REQUEST_CODE) {
        if (grantResults.length <= 0) {
            // If user interaction was interrupted, the permission request is cancelled and you
            // receive empty arrays.
            Log.i("Error", "User interaction was cancelled.");
        } else if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // Permission was granted. Kick off the process of building and connecting
            // GoogleApiClient.
            getCallDetails();
        } else {
        }
    }

}

public类MainActivity扩展了AppCompatActivity{
私有静态最终整数请求\权限\请求\代码=1；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
如果（！checkPermissions（））{
请求权限（）；
}否则{
getCallDetails（）；
}
}
私有void getCallDetails（）{
StringBuffer sb=新的StringBuffer（）；
Uri contacts=CallLog.Calls.CONTENT\u Uri；
Cursor managedCursor=this.getContentResolver（）.query（contacts，null，null，null）；
int number=managedCursor.getColumnIndex（CallLog.Calls.number）；
int type=managedCursor.getColumnIndex（CallLog.Calls.type）；
int date=managedCursor.getColumnIndex（CallLog.Calls.date）；
int duration=managedCursor.getColumnIndex（CallLog.Calls.duration）；
某人附加（“通话详情：”）；
while（managedCursor.moveToNext（））{
HashMap rowDataCall=新建HashMap（）；
字符串phNumber=managedCursor.getString（数字）；
String callType=managedCursor.getString（类型）；
String callDate=managedCursor.getString（日期）；
字符串callDay=新日期（Long.valueOf（callDate））.toString（）；
//长时间戳=转换日期到时间戳（CallDaily）；
String callDuration=managedCursor.getString（duration）；
字符串dir=null；
int dircode=Integer.parseInt（callType）；
开关（dircode）{
案例CallLog.Calls.OUTGOING_类型：
dir=“传出”；
打破
案例CallLog.Calls.INCOMING_类型：
dir=“传入”；
打破
案例CallLog.Calls.MISSED_类型：
dir=“MISSED”；
打破
}
sb.追加（“\n电话号码：——“+phNumber+”\n呼叫类型：——“+dir+”\n呼叫日期：——“+callday+”\n呼叫持续时间（秒）：——“+callDuration）；
sb.追加（“\n---------------------------------------------------”）；
}
managedCursor.close（）；
系统输出打印LN（sb）；
}
/**
*此方法用于请求权限。
*/
私有void requestPermissions（）{
布尔应提供=
ActivityCompat.应显示请求许可理由（此，
Manifest.permission.READ\u CALL\u LOG）；
如果（应提供）{
}否则{
Log.i（“错误”，“请求许可”）；
//之前，选中“永不再问”。
ActivityCompat.requestPermissions（MainActivity.this，
新字符串[]{Manifest.permission.READ_CALL_LOG}，
请求\权限\请求\代码）；
}
}
/**
*此方法检查权限并返回权限需要的当前状态。
*/
私有布尔检查权限（）{
int permissionState=ActivityCompat.checkSelfPermission（此，
Manifest.permission.READ\u CALL\u LOG）；
返回permissionState==PackageManager.PERMISSION\u已授予；
}
@凌驾
public void onRequestPermissionsResult（int-requestCode，@NonNull-String[]permissions，@NonNull-int[]grantResults）{
super.onRequestPermissionsResult（请求代码、权限、授权结果）；
if（requestCode==请求权限请求代码）{
如果（grantResults.length您似乎想计时通话，并在10分钟后结束通话

因此，我建议启动一个计时器，为10分钟的对话计时，然后使用处理程序，检查同一个呼叫是否仍在进行：如果继续->结束它

在Java中：

//call this method when call is starting
void startTimer() {
    new Handler().postDelayed(new Runnable() {
        @Override
        public void run() {//this method will execute after 10 minutes
            //check if call is still on going
            //if so - write the logic to end call here
        }
    }, 1000 * 60 * 10); //10 min in milli-seconds
}

在科特林：

//call this method when call is starting
private fun startTimer() {
    Handler().postDelayed({ //this method will execute after 10 minutes
        //check if call is still on going
        //if so - write the logic to end call here
    }, 1000 * 60 * 10) //10 min in milli-seconds
}

说清楚一点，你想在10分钟后暂停通话吗？@GalYedidovich。是的，准确地说，它只能得到通话中断后的时间，对吗？我的目标是在10分钟后断开通话！那么我怎么能理解用户在n分钟后断开通话的时间呢？你能分享一个示例代码吗？我是android初学者！是的，我会创建一个现在；）
//call this method when call is starting
private fun startTimer() {
    Handler().postDelayed({ //this method will execute after 10 minutes
        //check if call is still on going
        //if so - write the logic to end call here
    }, 1000 * 60 * 10) //10 min in milli-seconds
}