1 /*
2  * Copyright (C) 2019 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 
23 import android.telephony.SmsManager;
24 import android.telephony.SmsMessage;
25 import android.telephony.ims.stub.ImsSmsImplBase;
26 import android.util.Log;
27 
28 import java.util.concurrent.CountDownLatch;
29 import java.util.concurrent.TimeUnit;
30 
31 public class TestImsSmsImpl extends ImsSmsImplBase {
32     private static final String TAG = "CtsTestImsService";
33 
34     private CountDownLatch mSentTriggeredLatch = new CountDownLatch(1);
35     private CountDownLatch mOnReadyLatch = new CountDownLatch(1);
36     private CountDownLatch mAckDeliveryLatch = new CountDownLatch(1);
37     private CountDownLatch mSmsAckLatch = new CountDownLatch(1);
38     private CountDownLatch mOnMemoryAvailableLatch = new CountDownLatch(1);
39     // Expecting only one message at a time
40     public byte[] sentPdu;
41     private int mToken;
42     private int mMessageRef;
43     private int mResult;
44     public byte[] ackPdu;
45     public  boolean mMemoryEventReceived = false;
46 
47     @Override
sendSms(int token, int messageRef, String format, String smsc, boolean isRetry, byte[] pdu)48     public void sendSms(int token, int messageRef, String format, String smsc, boolean isRetry,
49             byte[] pdu) {
50         if (ImsUtils.VDBG) {
51             Log.d(TAG, "ImsSmsImplBase.sendSms called");
52         }
53         sentPdu = pdu;
54         mToken = token;
55         mMessageRef = messageRef;
56 
57         mSentTriggeredLatch.countDown();
58     }
59 
60     @Override
getSmsFormat()61     public String getSmsFormat() {
62         return SmsMessage.FORMAT_3GPP;
63     }
64 
65     @Override
onReady()66     public void onReady() {
67         if (ImsUtils.VDBG) {
68             Log.d(TAG, "ImsSmsImplBase.onReady called");
69         }
70         mOnReadyLatch.countDown();
71 
72     }
73 
74     @Override
acknowledgeSms(int token, int messageRef, int result)75     public void acknowledgeSms(int token, int messageRef, int result) {
76         mToken = token;
77         mMessageRef = messageRef;
78         mResult = result;
79         mSmsAckLatch.countDown();
80     }
81 
82     @Override
acknowledgeSmsReport(int token, int messageRef, int result)83     public void acknowledgeSmsReport(int token, int messageRef, int result) {
84         mToken = token;
85         mMessageRef = messageRef;
86         mResult = result;
87         mAckDeliveryLatch.countDown();
88     }
89 
90     @Override
acknowledgeSms(int token, int messageRef, int result, byte[] pdu)91     public void acknowledgeSms(int token, int messageRef, int result, byte[] pdu) {
92         Log.d(TAG, "acknowledgeSms");
93         mToken = token;
94         mMessageRef = messageRef;
95         mResult = result;
96         ackPdu = pdu;
97         mSmsAckLatch.countDown();
98     }
99 
getMessageRef()100     public int getMessageRef() {
101         return mMessageRef;
102     }
103 
onMemoryAvailable(int token)104     public void onMemoryAvailable(int token) {
105         mToken = token;
106         mMemoryEventReceived = true;
107         mOnMemoryAvailableLatch.countDown();
108     }
109 
receiveSmsWaitForAcknowledgeMemoryFull(int token, String format, byte[] pdu)110     public void receiveSmsWaitForAcknowledgeMemoryFull(int token, String format, byte[] pdu) {
111         onSmsReceived(token, format, pdu);
112         boolean complete = false;
113         try {
114             complete = mSmsAckLatch.await(ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
115         } catch (InterruptedException e) {
116             // complete == false
117         }
118 
119         assertTrue("Timed out waiting for acknowledgeSms.", complete);
120         assertEquals("Token mismatch.", token, mToken);
121         assertTrue("Invalid messageRef", mMessageRef >= 0);
122         assertEquals("Invalid result in acknowledgeSms. Result = " + mResult,
123                                                 DELIVER_STATUS_ERROR_NO_MEMORY, mResult);
124     }
125 
receiveSmsWaitForAcknowledge(int token, String format, byte[] pdu)126     public void receiveSmsWaitForAcknowledge(int token, String format, byte[] pdu) {
127         onSmsReceived(token, format, pdu);
128         boolean complete = false;
129         try {
130             complete = mSmsAckLatch.await(ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
131         } catch (InterruptedException e) {
132             // complete == false
133         }
134 
135         assertTrue("Timed out waiting for acknowledgeSms.", complete);
136         assertEquals("Token mismatch.", token, mToken);
137         assertTrue("Invalid messageRef", mMessageRef >= 0);
138         assertEquals("Invalid result in acknowledgeSms. Result = " + mResult,
139                                                               DELIVER_STATUS_OK, mResult);
140     }
141 
sendReportWaitForAcknowledgeSmsReportR(int token, String format, byte[] pdu)142     public void sendReportWaitForAcknowledgeSmsReportR(int token, String format, byte[] pdu) {
143         onSmsStatusReportReceived(token, format, pdu);
144         boolean complete = false;
145         try {
146             complete = mAckDeliveryLatch.await(ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
147         } catch (InterruptedException e) {
148             // complete = false
149         }
150         assertTrue("Timed out waiting for delivery report.", complete);
151         assertEquals("Ttoken mismatch.", token, mToken);
152         assertEquals("Status mismatch.", STATUS_REPORT_STATUS_OK, mResult);
153     }
154 
155 
156     // Deprecated method for P and Q, where mToken is expected to be the framework token
sendReportWaitForAcknowledgeSmsReportPQ(int messageRef, String format, byte[] pdu)157     public void sendReportWaitForAcknowledgeSmsReportPQ(int messageRef, String format,
158             byte[] pdu) {
159         onSmsStatusReportReceived(mToken, messageRef, format, pdu);
160         boolean complete = false;
161         try {
162             complete = mAckDeliveryLatch.await(ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
163         } catch (InterruptedException e) {
164             // complete = false
165         }
166         assertTrue("Timed out waiting for delivery report.", complete);
167         assertEquals("MessageRef mismatch.", messageRef, mMessageRef);
168         assertEquals("Status mismatch.", STATUS_REPORT_STATUS_OK, mResult);
169     }
170 
171     // P-Q API
waitForMessageSentLatch()172     public boolean waitForMessageSentLatch() {
173         boolean complete = false;
174         try {
175             complete = mSentTriggeredLatch.await(ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
176             onSendSmsResult(mToken, mMessageRef, ImsSmsImplBase.SEND_STATUS_OK,
177                     SmsManager.RESULT_ERROR_NONE);
178         } catch (InterruptedException e) {
179             // complete = false
180         }
181         return complete;
182     }
183 
184     // R+ API
waitForMessageSentLatchSuccess()185     public boolean waitForMessageSentLatchSuccess() {
186         boolean complete = false;
187         try {
188             complete = mSentTriggeredLatch.await(ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
189             onSendSmsResultSuccess(mToken, mMessageRef);
190         } catch (InterruptedException e) {
191             // complete = false
192         }
193         return complete;
194     }
195 
196     // R+ API
waitForMessageSentLatchError(int resultCode, int networkErrorCode)197     public boolean waitForMessageSentLatchError(int resultCode, int networkErrorCode) {
198         boolean complete = false;
199         try {
200             complete = mSentTriggeredLatch.await(ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
201             onSendSmsResultError(mToken, mMessageRef, ImsSmsImplBase.SEND_STATUS_ERROR,
202                         resultCode, networkErrorCode);
203         } catch (InterruptedException e) {
204             // complete = false
205         }
206         return complete;
207     }
208 
waitForOnMemoryAvailableLatch()209     public boolean waitForOnMemoryAvailableLatch() {
210         boolean complete = false;
211         try {
212             complete = mOnMemoryAvailableLatch.await(ImsUtils.TEST_TIMEOUT_MS,
213                                                      TimeUnit.MILLISECONDS);
214             onMemoryAvailableResult(mToken, ImsSmsImplBase.SEND_STATUS_OK,
215                     SmsManager.RESULT_ERROR_NONE);
216         } catch (InterruptedException e) {
217             // complete = false
218         }
219 
220         return complete;
221     }
222 
waitForOnReadyLatch()223     public boolean waitForOnReadyLatch() {
224         boolean complete = false;
225         try {
226             complete = mOnReadyLatch.await(ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
227         } catch (InterruptedException e) {
228             // complete = false
229         }
230 
231         return complete;
232     }
233 
234 }
235