Java电话监听器【精品博客】

模拟拨打电话，接听电话，挂断电话，拨打为空号，等等，这些动作用Java接口监听的方式来完成，主要是为了训练使用接口监听回调；

---

        /**
         * 业务场景一：
         * 【萍萍】--->请输入手机号码进行拨打...
         * 13787686565
         * 【刘德利】-->萍萍 13787878789 接听(j) 挂断(g)
         * j
         * 【萍萍】--->对方已接听，正在通话中...
         *
         * 业务场景二：
         * 【萍萍】--->请输入手机号码进行拨打...
         * 13787686565
         * 【刘德利】-->萍萍 13787878789 接听(j) 挂断(g)
         * g
         * 【萍萍】--->对方已挂断。
         *
         * 业务场景三：
         * 【萍萍】--->请输入手机号码进行拨打...
         * 13787686566
         * 【萍萍】-->电话号码是空号
         */

---

执行效果：

---

电话接口监听的具体实现代码：

package com.call.listener.phone;

/**
 * 定义拨打出错接口
 * @author Liudeli
 *
 */
public interface OnCallError {

    /**
     * 定义拨打出现错误的方法
     * @param error
     */
    public void callError(String error);

}

package com.call.listener.phone;

/**
 * 拨打被挂断接口回调
 * @author Liudeli
 *
 */
public interface OnCallRefuse {

    /**
     * 此行为是拨打被挂断的行为
     * @param callRefuse
     */
    public void callRefuse(String callRefuse);

}

package com.call.listener.phone;

/**
 * 成功监听接口回调
 * @author Liudeli
 *
 */
public interface OnCallSuccess {

    /**
     * 接听成功监听行为标准
     * @param success 传入成功信息数据
     */
    public void callSuccess(String success);

}

package com.call.listener.phone;

/**
 * 是否接听接口回调
 * @author Liudeli
 *
 */
public interface OnCallWhetherAnswer {

    /**
     * 此方法用于询问被拨打着是否接听
     * @param whetherAnswer
     */
    public void whetherAnswer(String whetherAnswer);

}

package com.call.listener.phone;

/**
 * Phone配置对象
 * @author Liudeli
 *
 */
public class PhoneConfig {

    /**
     * 通讯录名称（拨打者）
     */
    public static final String contactsName = "【萍萍】";

    /**
     * 通讯录手机号码（拨打者）
     */
    // public static final String contactsNumber = "13787878789";

    /**
     * 通讯录名称（被拨打者）
     */
    public static final String contactsNameAnswer = "【刘德利】";

    /**
     * 通讯录手机号码（被拨打者）
     */
    public static final String contactsNumberAnswer = "13787686565";

}

package com.call.listener.phone;

/**
 * 定义电话接口标准规范
 * @author Liudeli
 *
 */
public interface IPhone {

    /**
     * 主动拨打电话
     * @param name   传入拨打者名称
     * @param number 传入拨打着电话号码
     * @return 返回当前对象本身
     */
    public Phone call(String name, String number);

    /**
     * 主动拨打引发的错误监听
     * @param callError 拨打出错接口（用于接口回调）
     * @return 返回当前对象本身
     */
    public Phone callErrorListener(OnCallError callError);

    /**
     * 询问被拨打者是否接听
     * @param callWhetherAnswer 是否接听来电信息（用于接口回调）
     * @return 返回当前对象本身
     */
    public Phone callWhetherAnswerListener(OnCallWhetherAnswer callWhetherAnswer);

    /**
     * 被拨打者成功接听监听
     * @param callSuccess 接听成功接口（用于接口回调）
     * @return 返回当前对象本身
     */
    public Phone callSuccessListener(OnCallSuccess callSuccess);

    /**
     * 被拨打者挂断监听
     * @param callRefuse 挂断接口（用于接口回调）
     * @return 返回当前对象本身
     */
    public Phone callRefuseListener(OnCallRefuse callRefuse);

    /**
     * 成功接听通知
     */
    public void successCall();

    /**
     * 挂断电话通知
     */
    public void refuseCall();

    /**
     * 点击拨打电话
     */
    public void onClickCall();

}

package com.call.listener.phone;

/**
 * 电话监听拨打具体实现类
 * @author Liudeli
 */
public class Phone implements IPhone {

    /**
     * 定义单例模式
     */
    private static Phone phone = null;

    public static Phone getInstance() {
        if (null == phone) {
            synchronized (Phone.class) {
                phone = new Phone();
            }
        }
        return phone;
    }

    // 保存变量名称
    private String name;
    // 保存变量电话号码
    private String number;

    public Phone call(String name, String number) {
        this.name = name;
        this.number = number;
        return this;
    }

    // 保存拨打错误接口
    private OnCallError callError;

    public Phone callErrorListener(OnCallError callError) {
        this.callError = callError;
        return this;
    }

    // 保存是否接听接口
    private OnCallWhetherAnswer callWhetherAnswer;

    public Phone callWhetherAnswerListener(OnCallWhetherAnswer callWhetherAnswer) {
        this.callWhetherAnswer = callWhetherAnswer;
        return this;
    }

    // 保存成功接听接口
    private OnCallSuccess callSuccess;

    public Phone callSuccessListener(OnCallSuccess callSuccess) {
        this.callSuccess = callSuccess;
        return this;
    }

    // 保护挂断接口
    private OnCallRefuse callRefuse;

    public Phone callRefuseListener(OnCallRefuse callRefuse) {
        this.callRefuse = callRefuse;
        return this;
    }

    public void successCall() {
        callSuccess.callSuccess(PhoneConfig.contactsName+ "--->" + "对方已接听，正在通话中...");
    }

    public void refuseCall() {
        callRefuse.callRefuse(PhoneConfig.contactsName+ "--->" + "对方已挂断...");
    }

    public void onClickCall() {
        if (PhoneConfig.contactsNumberAnswer.equals(number)) {
            // 电话号码拨打正确 successs
            callWhetherAnswer.whetherAnswer(PhoneConfig.contactsNameAnswer
                    + "--->" + "萍萍 13787878789 接听(j) 挂断(g)");
        } else {
            // 电话号码拨打错误
            callError.callError(PhoneConfig.contactsName + "--->" + "电话号码是空号。");
        }
    }

}

package com.call.listener;

import java.util.Scanner;
import com.call.listener.phone.IPhone;
import com.call.listener.phone.OnCallRefuse;
import com.call.listener.phone.OnCallSuccess;
import com.call.listener.phone.OnCallError;
import com.call.listener.phone.OnCallWhetherAnswer;
import com.call.listener.phone.Phone;
import com.call.listener.phone.PhoneConfig;

/**
 * 电话监听器测试端程序
 * @author Liudeli
 *
 */
public class Main {

    private static Scanner scanner;
    private static IPhone iPhone;

    public static void main(String[] args) {

        /**
         * 业务场景一：
         * 【萍萍】--->请输入手机号码进行拨打...
         * 13787686565
         * 【刘德利】-->萍萍 13787878789 接听(j) 挂断(g)
         * j
         * 【萍萍】--->对方已接听，正在通话中...
         *
         * 业务场景二：
         * 【萍萍】--->请输入手机号码进行拨打...
         * 13787686565
         * 【刘德利】-->萍萍 13787878789 接听(j) 挂断(g)
         * g
         * 【萍萍】--->对方已挂断。
         *
         * 业务场景三：
         * 【萍萍】--->请输入手机号码进行拨打...
         * 13787686566
         * 【萍萍】-->电话号码是空号
         */

        scanner = new Scanner(System.in);

        System.out.println("请输入手机号码进行拨打...");
        String number = scanner.nextLine();

        iPhone = Phone.getInstance();
        // 打电话动作
        iPhone.call(PhoneConfig.contactsName, number)
        .callErrorListener(callError)
        .callWhetherAnswerListener(callWhetherAnswer)
        .callSuccessListener(callAnswer)
        .callRefuseListener(callRefuse)
        .onClickCall();
    }

    /**
     * 监听拨打出错的业务处理
     * (注意:这里本应该不需要写 static静态，
     *  由于 main测试程序是main，所以才写static)
     */
    private static OnCallError callError = new OnCallError() {

        public void callError(String error) {
            System.out.println(error);
        }
    };

    /**
     * 监听是否接听拨打者的电话
     * (注意:这里本应该不需要写 static静态，
     *  由于 main测试程序是main，所以才写static)
     */
    private static OnCallWhetherAnswer
                callWhetherAnswer = new OnCallWhetherAnswer() {

        public void whetherAnswer(String whetherAnswer) {
            System.out.println(whetherAnswer);
            String isAnswer = scanner.nextLine();
            if ("j".equals(isAnswer)) {
                iPhone.successCall();
            } else {
                iPhone.refuseCall();
            }
        }
    };

    /**
     * 监听成功接听拨打者的电话
     * (注意:这里本应该不需要写 static静态，
     *  由于 main测试程序是main，所以才写static)
     */
    private static OnCallSuccess callAnswer = new OnCallSuccess() {

        public void callSuccess(String success) {
            System.out.println(success);
        }
    };

    /**
     * 监听被挂断
     * (注意:这里本应该不需要写 static静态，
     *  由于 main测试程序是main，所以才写static)
     */
    private static OnCallRefuse callRefuse = new OnCallRefuse() {

        public void callRefuse(String callRefuse) {
            System.out.println(callRefuse);
        }
    };

}

---

注意：我这这里用来四个接口监听，其实只需一个就可以了

---

谢谢大家的观看，更多精彩技术博客，会不断的更新，请大家访问，

刘德利CSDN博客， http://blog.csdn.net/u011967006