648540858
2022-03-03 14174ff40022a1f7662759d478d06b7b350ccd98
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
package com.genersoft.iot.vmp.gb28181.event;
 
import com.genersoft.iot.vmp.gb28181.bean.DeviceNotFoundEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
 
import javax.sip.*;
import javax.sip.header.CallIdHeader;
import javax.sip.message.Response;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
@Component
public class SipSubscribe {
 
    private final Logger logger = LoggerFactory.getLogger(SipSubscribe.class);
 
    private Map<String, SipSubscribe.Event> errorSubscribes = new ConcurrentHashMap<>();
 
    private Map<String, SipSubscribe.Event> okSubscribes = new ConcurrentHashMap<>();
 
    private Map<String, Date> okTimeSubscribes = new ConcurrentHashMap<>();
    private Map<String, Date> errorTimeSubscribes = new ConcurrentHashMap<>();
 
    //    @Scheduled(cron="*/5 * * * * ?")   //每五秒执行一次
//    @Scheduled(fixedRate= 100 * 60 * 60 )
    @Scheduled(cron="0 0/5 * * * ?")   //每5分钟执行一次
    public void execute(){
        logger.info("[定时任务] 清理过期的订阅信息");
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.set(Calendar.MINUTE, calendar.get(Calendar.MINUTE) - 5);
 
        for (String key : okTimeSubscribes.keySet()) {
            if (okTimeSubscribes.get(key).before(calendar.getTime())){
//                logger.info("[定时任务] 清理过期的订阅信息: {}", key);
                okSubscribes.remove(key);
                okTimeSubscribes.remove(key);
            }
        }
        for (String key : errorTimeSubscribes.keySet()) {
            if (errorTimeSubscribes.get(key).before(calendar.getTime())){
//                logger.info("[定时任务] 清理过期的订阅信息: {}", key);
                errorSubscribes.remove(key);
                errorTimeSubscribes.remove(key);
            }
        }
        logger.info("okTimeSubscribes.size:{}",okTimeSubscribes.size());
        logger.info("okSubscribes.size:{}",okSubscribes.size());
        logger.info("errorTimeSubscribes.size:{}",errorTimeSubscribes.size());
        logger.info("errorSubscribes.size:{}",errorSubscribes.size());
    }
 
    public interface Event {
        void response(EventResult eventResult);
    }
 
    public static class EventResult<EventObject>{
        public int statusCode;
        public String type;
        public String msg;
        public String callId;
        public Dialog dialog;
        public EventObject event;
 
        public EventResult() {
        }
 
        public EventResult(EventObject event) {
            this.event = event;
            if (event instanceof ResponseEvent) {
                ResponseEvent responseEvent = (ResponseEvent)event;
                Response response = responseEvent.getResponse();
                this.dialog = responseEvent.getDialog();
                this.type = "response";
                if (response != null) {
                    this.msg = response.getReasonPhrase();
                    this.statusCode = response.getStatusCode();
                }
                this.callId = ((CallIdHeader)response.getHeader(CallIdHeader.NAME)).getCallId();
 
            }else if (event instanceof TimeoutEvent) {
                TimeoutEvent timeoutEvent = (TimeoutEvent)event;
                this.type = "timeout";
                this.msg = "消息超时未回复";
                this.statusCode = -1024;
                this.callId = timeoutEvent.getClientTransaction().getDialog().getCallId().getCallId();
                this.dialog = timeoutEvent.getClientTransaction().getDialog();
            }else if (event instanceof TransactionTerminatedEvent) {
                TransactionTerminatedEvent transactionTerminatedEvent = (TransactionTerminatedEvent)event;
                this.type = "transactionTerminated";
                this.msg = "事务已结束";
                this.statusCode = -1024;
                this.callId = transactionTerminatedEvent.getClientTransaction().getDialog().getCallId().getCallId();
                this.dialog = transactionTerminatedEvent.getClientTransaction().getDialog();
            }else if (event instanceof DialogTerminatedEvent) {
                DialogTerminatedEvent dialogTerminatedEvent = (DialogTerminatedEvent)event;
                this.type = "dialogTerminated";
                this.msg = "会话已结束";
                this.statusCode = -1024;
                this.callId = dialogTerminatedEvent.getDialog().getCallId().getCallId();
                this.dialog = dialogTerminatedEvent.getDialog();
            }else if (event instanceof DeviceNotFoundEvent) {
                DeviceNotFoundEvent deviceNotFoundEvent = (DeviceNotFoundEvent)event;
                this.type = "deviceNotFoundEvent";
                this.msg = "设备未找到";
                this.statusCode = -1024;
                this.callId = deviceNotFoundEvent.getDialog().getCallId().getCallId();
                this.dialog = deviceNotFoundEvent.getDialog();
            }
        }
    }
 
    public void addErrorSubscribe(String key, SipSubscribe.Event event) {
        errorSubscribes.put(key, event);
        errorTimeSubscribes.put(key, new Date());
    }
 
    public void addOkSubscribe(String key, SipSubscribe.Event event) {
        okSubscribes.put(key, event);
        okTimeSubscribes.put(key, new Date());
    }
 
    public SipSubscribe.Event getErrorSubscribe(String key) {
        return errorSubscribes.get(key);
    }
 
    public void removeErrorSubscribe(String key) {
        errorSubscribes.remove(key);
        errorTimeSubscribes.remove(key);
    }
 
    public SipSubscribe.Event getOkSubscribe(String key) {
        return okSubscribes.get(key);
    }
 
    public void removeOkSubscribe(String key) {
        okSubscribes.remove(key);
        okTimeSubscribes.remove(key);
    }
    public int getErrorSubscribesSize(){
        return errorSubscribes.size();
    }
    public int getOkSubscribesSize(){
        return okSubscribes.size();
    }
}