-1

我正在使用下面的代码来检查手机状态（如果手机是开机或关机）。当手机关机时会发出警报。但是，这并没有显示 8800 系列手机何时停机。有没有其他方法可以检查电话注册/注销状态？

@Override public void terminalChangedEvent(TermEv[] eventList) {
        if ( eventList != null ) {
            for (TermEv eventList1 : eventList) {
                 if (eventList1 instanceof CiscoTermInServiceEv){
                    if(terminalInService.test()==true){
                        LogSQL.removeLog(terminal.getName());
                     }
                    System.out.println(terminal.getName());
                    terminalInService.set();
                    return;
                } else if (eventList1 instanceof CiscoTermOutOfServiceEv && 
                    terminalInService.test()==true) {
                    offline();
                }
            }
         }
       }

第二个问题，我找不到有关“com.cisco.cti.util.Condition”类的方法或文档。Condition.set() 和 Condition.test() 方法有什么作用？

4

1 回答 1

0

看起来您有正确的总体思路 - JTAPI 应该适用于 88xx 型号，假设您具有正确的设备-> 用户关联和用户权限（启用标准 CTI，标准 CTI 允许控制支持 Connected Xfer 和所需的配置的电话88xx）。

这是我在 CUCM 11.5 上工作的版本：

package com.mycompany.app;

import com.cisco.jtapi.extensions.*;
import java.util.*;
import javax.telephony.*;
import javax.telephony.events.*;
import javax.telephony.callcontrol.*;
import javax.telephony.callcontrol.events.*;
import com.cisco.cti.util.Condition;

public class DataTerm implements ProviderObserver, TerminalObserver {

    public static final int OUT_OF_SERVICE = 0;
    public static final int IN_SERVICE = 1;
    private Address destAddress;
    private CiscoTerminal observedTerminal;
    private boolean addressInService;
    private boolean terminalInService;
    protected int state = OUT_OF_SERVICE;
    Condition conditionInService = new Condition();
    Provider provider;

    public DataTerm(String[] args) {
        try {
            System.out.println("Initializing Jtapi");
            String providerName = "ds-ucm115-1.cisco.com";
            String login = "dstaudt";
            String passwd = "password";
            String dest = "2999";
            JtapiPeer peer = JtapiPeerFactory.getJtapiPeer(null);
            String providerString = providerName + ";login=" + login + ";passwd=" + passwd;
            System.out.println("Opening " + providerString + "...\n");
            provider = peer.getProvider(providerString);
            provider.addObserver(this);
            conditionInService.waitTrue();
            this.destAddress = provider.getAddress(dest);
            this.observedTerminal = (CiscoTerminal) destAddress.getTerminals()[0];
            try {
                if (destAddress != null) {
                    System.out.println("Adding Terminal Observer to Terminal" + observedTerminal.getName());
                    observedTerminal.addObserver(this);
                }
            } catch (Exception e) {
            }
        } catch (Exception e) {
            System.out.println("Caught exception " + e);
        }
    }

    public void terminalChangedEvent(TermEv[] events) {
        for (int i = 0; i < events.length; i++) {
            Terminal terminal = events[i].getTerminal();
            switch (events[i].getID()) {
            case CiscoTermInServiceEv.ID:
                System.out.println("Received " + events[i] + "for " + terminal.getName());
                terminalInService = true;
                break;
            case CiscoTermOutOfServiceEv.ID:
                System.out.println("Received " + events[i] + "for " + terminal.getName());
                terminalInService = false;
                if (state != OUT_OF_SERVICE) { // you only want to notify when you had notified earlier that you are IN_SERVICE
                    state = OUT_OF_SERVICE;
                }
                break;
            }
        }
    }

    public void providerChangedEvent(ProvEv[] eventList) {
        if (eventList != null) {
            for (int i = 0; i < eventList.length; i++) {
                if (eventList[i] instanceof ProvInServiceEv) {
                    conditionInService.set();
                }
            }
        }
    }

}

“com.cisco.cti.util.Condition”似乎基于这种模式：

公共接口条件

Condition 将对象监视器方法（wait、notify 和 notifyAll）分解为不同的对象，通过将它们与任意 Lock 实现的使用结合起来，使每个对象具有多个等待集的效果。Lock 代替了同步方法和语句的使用，Condition 代替了 Object 监视器方法的使用。

条件（也称为条件队列或条件变量）为一个线程提供了一种暂停执行（“等待”）的方法，直到另一个线程通知某个状态条件现在可能为真。因为对这种共享状态信息的访问发生在不同的线程中，所以它必须受到保护，所以某种形式的锁与条件相关联。等待条件提供的关键属性是它以原子方式释放关联的锁并挂起当前线程，就像 Object.wait 一样。

https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/Condition.html

于 2018-03-06T19:36:35.250 回答