1 /*
2  * Copyright (C) 2020 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.telephony.ims.cts;
18 
19 import static junit.framework.Assert.assertTrue;
20 
21 import static org.junit.Assert.assertEquals;
22 import static org.junit.Assert.assertNotNull;
23 
24 import android.telephony.ims.DelegateMessageCallback;
25 import android.telephony.ims.DelegateRegistrationState;
26 import android.telephony.ims.DelegateRequest;
27 import android.telephony.ims.DelegateStateCallback;
28 import android.telephony.ims.FeatureTagState;
29 import android.telephony.ims.SipDelegateConfiguration;
30 import android.telephony.ims.SipMessage;
31 import android.telephony.ims.stub.SipDelegate;
32 import android.util.ArraySet;
33 import android.util.Log;
34 import android.util.Pair;
35 
36 import androidx.annotation.NonNull;
37 
38 import java.util.Set;
39 import java.util.concurrent.LinkedBlockingQueue;
40 import java.util.concurrent.TimeUnit;
41 
42 public class TestSipDelegate implements SipDelegate {
43     private static final String LOG_TAG = "CtsImsSipDelegate";
44 
45     public final int subId;
46     public final DelegateRequest delegateRequest;
47     private final DelegateStateCallback mStateCallback;
48     private final DelegateMessageCallback mMessageCallback;
49 
50     private final LinkedBlockingQueue<SipMessage> mIncomingMessages = new LinkedBlockingQueue<>();
51     // Pair is <transactionId, error reason>
52     private final LinkedBlockingQueue<Pair<String, Integer>> mReceivedMessageAcks =
53             new LinkedBlockingQueue<>();
54     private final LinkedBlockingQueue<String> mCleanupSipSessionRequests =
55             new LinkedBlockingQueue<>();
56     private int mSendMessageDenyReason = -1;
57 
TestSipDelegate(int sub, DelegateRequest request, DelegateStateCallback cb, DelegateMessageCallback mc)58     public TestSipDelegate(int sub, DelegateRequest request, DelegateStateCallback cb,
59             DelegateMessageCallback mc) {
60         subId = sub;
61         delegateRequest = request;
62         mStateCallback = cb;
63         mMessageCallback = mc;
64     }
65 
66     @Override
sendMessage(@onNull SipMessage message, long configVersion)67     public void sendMessage(@NonNull SipMessage message, long configVersion) {
68         if (ImsUtils.VDBG) Log.d(LOG_TAG, "sendMessage");
69         mIncomingMessages.offer(message);
70         if (mSendMessageDenyReason > -1) {
71             mMessageCallback.onMessageSendFailure(message.getViaBranchParameter(),
72                     mSendMessageDenyReason);
73         } else {
74             mMessageCallback.onMessageSent(message.getViaBranchParameter());
75         }
76     }
77 
78     @Override
cleanupSession(@onNull String callId)79     public void cleanupSession(@NonNull String callId) {
80         if (ImsUtils.VDBG) Log.d(LOG_TAG, "CleanSession");
81         mCleanupSipSessionRequests.offer(callId);
82     }
83 
84     @Override
notifyMessageReceived(@onNull String viaTransactionId)85     public void notifyMessageReceived(@NonNull String viaTransactionId) {
86         if (ImsUtils.VDBG) Log.d(LOG_TAG, "notifyMessageReceived");
87         mReceivedMessageAcks.offer(new Pair<>(viaTransactionId, -1));
88     }
89 
90     @Override
notifyMessageReceiveError(@onNull String viaTransactionId, int reason)91     public void notifyMessageReceiveError(@NonNull String viaTransactionId, int reason) {
92         if (ImsUtils.VDBG) Log.d(LOG_TAG, "notifyMessageReceiveError");
93         mReceivedMessageAcks.offer(new Pair<>(viaTransactionId, reason));
94     }
95 
verifyMessageSend(SipMessage messageToVerify)96     public void verifyMessageSend(SipMessage messageToVerify) throws Exception {
97         SipMessage m = mIncomingMessages.poll(ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
98         assertEquals(messageToVerify, m);
99     }
100 
verifyCleanupSession(String... callIdsToVerify)101     public void verifyCleanupSession(String... callIdsToVerify) throws Exception {
102         Set<String> ids = new ArraySet<>(callIdsToVerify);
103         for (int i = 0; i < callIdsToVerify.length; i++) {
104             String requestedCallId = mCleanupSipSessionRequests.poll(ImsUtils.TEST_TIMEOUT_MS,
105                     TimeUnit.MILLISECONDS);
106             assertTrue(ids.contains(requestedCallId));
107             ids.remove(requestedCallId);
108         }
109         assertTrue(ids.isEmpty());
110     }
111 
setSendMessageDenyReason(int reason)112     public void setSendMessageDenyReason(int reason) {
113         mSendMessageDenyReason = reason;
114     }
115 
receiveMessageAndVerifyReceivedCalled(SipMessage m)116     public void receiveMessageAndVerifyReceivedCalled(SipMessage m) throws Exception {
117         mMessageCallback.onMessageReceived(m);
118         Pair<String, Integer> transactionAndIdPair = mReceivedMessageAcks.poll(
119                 ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
120         assertEquals(m.getViaBranchParameter(), transactionAndIdPair.first);
121         assertNotNull(transactionAndIdPair.second);
122         assertEquals(-1, transactionAndIdPair.second.intValue());
123     }
124 
receiveMessageAndVerifyReceiveErrorCalled(SipMessage m, int reason)125     public void receiveMessageAndVerifyReceiveErrorCalled(SipMessage m, int reason)
126             throws Exception {
127         mMessageCallback.onMessageReceived(m);
128         Pair<String, Integer> transactionAndIdPair = mReceivedMessageAcks.poll(
129                 ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
130         assertEquals(m.getViaBranchParameter(), transactionAndIdPair.first);
131         assertNotNull(transactionAndIdPair.second);
132         assertEquals(reason, transactionAndIdPair.second.intValue());
133     }
134 
notifyImsRegistrationUpdate(DelegateRegistrationState state)135     public void notifyImsRegistrationUpdate(DelegateRegistrationState state) {
136         mStateCallback.onFeatureTagRegistrationChanged(state);
137     }
138 
notifyConfigurationUpdate(SipDelegateConfiguration config)139     public void notifyConfigurationUpdate(SipDelegateConfiguration config) {
140         mStateCallback.onConfigurationChanged(config);
141     }
142 
notifyOnCreated(Set<FeatureTagState> deniedTags)143     public void notifyOnCreated(Set<FeatureTagState> deniedTags) {
144         mStateCallback.onCreated(this, deniedTags);
145     }
146 
notifyOnDestroyed(int reason)147     public void notifyOnDestroyed(int reason) {
148         mStateCallback.onDestroyed(reason);
149     }
150 }
151