1/*
2 * Copyright (C) 2016 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
17package com.android.internal.telephony;
18
19import com.android.ims.ImsConfig;
20import com.android.ims.ImsReasonInfo;
21
22import android.net.ConnectivityMetricsEvent;
23import android.net.ConnectivityMetricsLogger;
24import android.net.IConnectivityMetricsLogger;
25import android.os.Bundle;
26import android.os.RemoteException;
27import android.telephony.ServiceState;
28import android.telephony.TelephonyManager;
29import android.test.suitebuilder.annotation.SmallTest;
30import android.util.ArrayMap;
31
32import static org.junit.Assert.*;
33import static org.mockito.Mockito.*;
34
35import org.hamcrest.BaseMatcher;
36import org.hamcrest.Description;
37import org.junit.After;
38import org.junit.Before;
39import org.junit.Test;
40import org.mockito.Mock;
41
42public class TelephonyEventLogTest extends TelephonyTest {
43    private static final String TAG = "TelephonyEventLogTest";
44
45    @Mock
46    private IConnectivityMetricsLogger.Stub mConnectivityMetricsLogger;
47
48    private TelephonyEventLog mEventLog;
49
50    private static final class TelephonyEventMatcher extends BaseMatcher<ConnectivityMetricsEvent> {
51        int mEventTag;
52        ArrayMap<String, Object> mMap = null;
53
54        public TelephonyEventMatcher(int eventTag, ArrayMap<String, Object> m) {
55            mEventTag = eventTag;
56            mMap = m;
57        }
58
59        @Override
60        public boolean matches(Object item) {
61            ConnectivityMetricsEvent e = (ConnectivityMetricsEvent) item;
62
63            if (e.componentTag != ConnectivityMetricsLogger.COMPONENT_TAG_TELEPHONY) {
64                logd("Component Tag, actual: " + e.componentTag);
65                return false;
66            }
67
68            if (e.eventTag != mEventTag) {
69                logd("Component Tag, expected: " + mEventTag + ", actual: " + e.eventTag);
70                return false;
71            }
72
73            Bundle b = (Bundle) e.data;
74
75            // compare only values stored in the map
76            for (int i=0; i < mMap.size(); i++) {
77                String key = mMap.keyAt(i);
78                Object value = mMap.valueAt(i);
79                if (!value.equals(b.get(key))) {
80                    logd("key: " + key + ", expected: " + value + ", actual: " + b.get(key));
81                    return false;
82                }
83            }
84
85            return true;
86        }
87
88        @Override
89        public void describeTo(Description description) {
90            description.appendText(" tag: " + mEventTag);
91            description.appendText(", data: " + mMap.toString());
92        }
93    }
94
95    @Before
96    public void setUp() throws Exception {
97        logd("setUp start");
98        super.setUp(TAG);
99
100        doReturn(mConnectivityMetricsLogger)
101                .when(mConnMetLoggerBinder)
102                .queryLocalInterface(anyString());
103
104        mEventLog = new TelephonyEventLog(0);
105    }
106
107    @After
108    public void tearDown() throws Exception {
109        mEventLog = null;
110        super.tearDown();
111    }
112
113    @Test @SmallTest
114    public void testWriteServiceStateChanged() {
115        ServiceState serviceState = new ServiceState();
116        serviceState.setVoiceRegState(ServiceState.STATE_IN_SERVICE);
117        serviceState.setDataRegState(ServiceState.STATE_IN_SERVICE);
118        serviceState.setVoiceRoamingType(ServiceState.ROAMING_TYPE_NOT_ROAMING);
119        serviceState.setDataRoamingType(ServiceState.ROAMING_TYPE_NOT_ROAMING);
120        serviceState.setVoiceOperatorName("Test Voice Long", "TestVoice", "12345");
121        serviceState.setDataOperatorName("Test Date Long", "TestData", "67890");
122        serviceState.setRilVoiceRadioTechnology(ServiceState.RIL_RADIO_TECHNOLOGY_LTE);
123        serviceState.setRilDataRadioTechnology(ServiceState.RIL_RADIO_TECHNOLOGY_LTE);
124
125        mEventLog.writeServiceStateChanged(serviceState);
126
127        ArrayMap<String, Object> m = new ArrayMap<>();
128        m.put(TelephonyEventLog.SERVICE_STATE_VOICE_REG_STATE, ServiceState.STATE_IN_SERVICE);
129        m.put(TelephonyEventLog.SERVICE_STATE_DATA_REG_STATE, ServiceState.STATE_IN_SERVICE);
130        m.put(TelephonyEventLog.SERVICE_STATE_VOICE_ROAMING_TYPE,
131                ServiceState.ROAMING_TYPE_NOT_ROAMING);
132        m.put(TelephonyEventLog.SERVICE_STATE_DATA_ROAMING_TYPE,
133                ServiceState.ROAMING_TYPE_NOT_ROAMING);
134        //m.put(TelephonyEventLog.SERVICE_STATE_VOICE_ALPHA_LONG, "Test Voice Long");
135        m.put(TelephonyEventLog.SERVICE_STATE_VOICE_ALPNA_SHORT, "TestVoice");
136        m.put(TelephonyEventLog.SERVICE_STATE_VOICE_NUMERIC, "12345");
137        //m.put(TelephonyEventLog.SERVICE_STATE_DATA_ALPHA_LONG, "Test Date Long");
138        m.put(TelephonyEventLog.SERVICE_STATE_DATA_ALPNA_SHORT, "TestData");
139        m.put(TelephonyEventLog.SERVICE_STATE_DATA_NUMERIC, "67890");
140        m.put(TelephonyEventLog.SERVICE_STATE_VOICE_RAT, ServiceState.RIL_RADIO_TECHNOLOGY_LTE);
141        m.put(TelephonyEventLog.SERVICE_STATE_DATA_RAT, ServiceState.RIL_RADIO_TECHNOLOGY_LTE);
142
143        m.put(TelephonyEventLog.DATA_KEY_PHONE_ID, 0);
144        m.put(TelephonyEventLog.DATA_KEY_PARAM1, -1);
145        m.put(TelephonyEventLog.DATA_KEY_PARAM2, -1);
146
147        try {
148            verify(mConnectivityMetricsLogger).logEvent(
149                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SERVICE_STATE, m)));
150        } catch (RemoteException e) {
151            fail(e.toString());
152        }
153    }
154
155    @Test @SmallTest
156    public void testWriteSetAirplaneMode() {
157        mEventLog.writeSetAirplaneMode(true);
158
159        ArrayMap<String, Object> m = new ArrayMap<>();
160        m.put(TelephonyEventLog.DATA_KEY_PHONE_ID, 0);
161        m.put(TelephonyEventLog.DATA_KEY_PARAM1, TelephonyEventLog.SETTING_AIRPLANE_MODE);
162        m.put(TelephonyEventLog.DATA_KEY_PARAM2, 1);
163
164        try {
165            verify(mConnectivityMetricsLogger).logEvent(
166                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
167        } catch (RemoteException e) {
168            fail(e.toString());
169        }
170
171        mEventLog.writeSetAirplaneMode(false);
172
173        m.put(TelephonyEventLog.DATA_KEY_PARAM2, 0);
174
175        try {
176            verify(mConnectivityMetricsLogger).logEvent(
177                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
178        } catch (RemoteException e) {
179            fail(e.toString());
180        }
181    }
182
183    @Test @SmallTest
184    public void testWriteSetCellDataEnabled() {
185        mEventLog.writeSetCellDataEnabled(true);
186
187        ArrayMap<String, Object> m = new ArrayMap<>();
188        m.put(TelephonyEventLog.DATA_KEY_PHONE_ID, 0);
189        m.put(TelephonyEventLog.DATA_KEY_PARAM1, TelephonyEventLog.SETTING_CELL_DATA_ENABLED);
190        m.put(TelephonyEventLog.DATA_KEY_PARAM2, 1);
191
192        try {
193            verify(mConnectivityMetricsLogger).logEvent(
194                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
195        } catch (RemoteException e) {
196            fail(e.toString());
197        }
198
199        mEventLog.writeSetCellDataEnabled(false);
200
201        m.put(TelephonyEventLog.DATA_KEY_PARAM2, 0);
202
203        try {
204            verify(mConnectivityMetricsLogger).logEvent(
205                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
206        } catch (RemoteException e) {
207            fail(e.toString());
208        }
209    }
210
211    @Test @SmallTest
212    public void testWriteSetDataRoamingEnabled() {
213        mEventLog.writeSetDataRoamingEnabled(true);
214
215        ArrayMap<String, Object> m = new ArrayMap<>();
216        m.put(TelephonyEventLog.DATA_KEY_PHONE_ID, 0);
217        m.put(TelephonyEventLog.DATA_KEY_PARAM1, TelephonyEventLog.SETTING_DATA_ROAMING_ENABLED);
218        m.put(TelephonyEventLog.DATA_KEY_PARAM2, 1);
219
220        try {
221            verify(mConnectivityMetricsLogger).logEvent(
222                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
223        } catch (RemoteException e) {
224            fail(e.toString());
225        }
226
227        mEventLog.writeSetDataRoamingEnabled(false);
228
229        m.put(TelephonyEventLog.DATA_KEY_PARAM2, 0);
230
231        try {
232            verify(mConnectivityMetricsLogger).logEvent(
233                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
234        } catch (RemoteException e) {
235            fail(e.toString());
236        }
237    }
238
239    @Test @SmallTest
240    public void testWriteSetPreferredNetworkType() {
241        mEventLog.writeSetPreferredNetworkType(RILConstants.NETWORK_MODE_GLOBAL);
242
243        ArrayMap<String, Object> m = new ArrayMap<>();
244        m.put(TelephonyEventLog.DATA_KEY_PHONE_ID, 0);
245        m.put(TelephonyEventLog.DATA_KEY_PARAM1, TelephonyEventLog.SETTING_PREFERRED_NETWORK_MODE);
246        m.put(TelephonyEventLog.DATA_KEY_PARAM2, RILConstants.NETWORK_MODE_GLOBAL);
247
248        try {
249            verify(mConnectivityMetricsLogger).logEvent(
250                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
251        } catch (RemoteException e) {
252            fail(e.toString());
253        }
254    }
255
256    @Test @SmallTest
257    public void testWriteSetWifiEnabled() {
258        mEventLog.writeSetWifiEnabled(true);
259
260        ArrayMap<String, Object> m = new ArrayMap<>();
261        m.put(TelephonyEventLog.DATA_KEY_PHONE_ID, 0);
262        m.put(TelephonyEventLog.DATA_KEY_PARAM1, TelephonyEventLog.SETTING_WIFI_ENABLED);
263        m.put(TelephonyEventLog.DATA_KEY_PARAM2, 1);
264
265        try {
266            verify(mConnectivityMetricsLogger).logEvent(
267                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
268        } catch (RemoteException e) {
269            fail(e.toString());
270        }
271
272        mEventLog.writeSetWifiEnabled(false);
273
274        m.put(TelephonyEventLog.DATA_KEY_PARAM2, 0);
275
276        try {
277            verify(mConnectivityMetricsLogger).logEvent(
278                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
279        } catch (RemoteException e) {
280            fail(e.toString());
281        }
282    }
283
284    @Test @SmallTest
285    public void testWriteSetWfcMode() {
286        mEventLog.writeSetWfcMode(ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED);
287
288        ArrayMap<String, Object> m = new ArrayMap<>();
289        m.put(TelephonyEventLog.DATA_KEY_PHONE_ID, 0);
290        m.put(TelephonyEventLog.DATA_KEY_PARAM1, TelephonyEventLog.SETTING_WFC_MODE);
291        m.put(TelephonyEventLog.DATA_KEY_PARAM2, ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED);
292
293        try {
294            verify(mConnectivityMetricsLogger).logEvent(
295                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
296        } catch (RemoteException e) {
297            fail(e.toString());
298        }
299    }
300
301    @Test @SmallTest
302    public void testWriteImsSetFeatureValue() {
303        mEventLog.writeImsSetFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VOICE_OVER_LTE,
304                TelephonyManager.NETWORK_TYPE_LTE, 1, ImsConfig.OperationStatusConstants.SUCCESS);
305
306        ArrayMap<String, Object> m = new ArrayMap<>();
307        m.put(TelephonyEventLog.DATA_KEY_PHONE_ID, 0);
308        m.put(TelephonyEventLog.DATA_KEY_PARAM1, TelephonyEventLog.SETTING_VO_LTE_ENABLED);
309        m.put(TelephonyEventLog.DATA_KEY_PARAM2, 1);
310
311        try {
312            verify(mConnectivityMetricsLogger).logEvent(
313                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
314        } catch (RemoteException e) {
315            fail(e.toString());
316        }
317
318        mEventLog.writeImsSetFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VOICE_OVER_WIFI,
319                TelephonyManager.NETWORK_TYPE_IWLAN, 1, ImsConfig.OperationStatusConstants.SUCCESS);
320
321        m.put(TelephonyEventLog.DATA_KEY_PARAM1, TelephonyEventLog.SETTING_VO_WIFI_ENABLED);
322
323        try {
324            verify(mConnectivityMetricsLogger).logEvent(
325                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
326        } catch (RemoteException e) {
327            fail(e.toString());
328        }
329
330        mEventLog.writeImsSetFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VIDEO_OVER_LTE,
331                TelephonyManager.NETWORK_TYPE_LTE, 1, ImsConfig.OperationStatusConstants.SUCCESS);
332
333        m.put(TelephonyEventLog.DATA_KEY_PARAM1, TelephonyEventLog.SETTING_VI_LTE_ENABLED);
334
335        try {
336            verify(mConnectivityMetricsLogger).logEvent(
337                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
338        } catch (RemoteException e) {
339            fail(e.toString());
340        }
341
342        mEventLog.writeImsSetFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VIDEO_OVER_WIFI,
343                TelephonyManager.NETWORK_TYPE_IWLAN, 1, ImsConfig.OperationStatusConstants.SUCCESS);
344
345        m.put(TelephonyEventLog.DATA_KEY_PARAM1, TelephonyEventLog.SETTING_VI_WIFI_ENABLED);
346
347        try {
348            verify(mConnectivityMetricsLogger).logEvent(
349                    argThat(new TelephonyEventMatcher(TelephonyEventLog.TAG_SETTINGS, m)));
350        } catch (RemoteException e) {
351            fail(e.toString());
352        }
353    }
354
355    @Test @SmallTest
356    public void testWriteImsConnectionState() {
357        mEventLog.writeOnImsConnectionState(
358                TelephonyEventLog.IMS_CONNECTION_STATE_CONNECTED, null);
359
360        ArrayMap<String, Object> m = new ArrayMap<>();
361        m.put(TelephonyEventLog.DATA_KEY_PHONE_ID, 0);
362        m.put(TelephonyEventLog.DATA_KEY_PARAM1, TelephonyEventLog.IMS_CONNECTION_STATE_CONNECTED);
363        m.put(TelephonyEventLog.DATA_KEY_PARAM2, -1);
364
365        try {
366            verify(mConnectivityMetricsLogger).logEvent(
367                    argThat(new TelephonyEventMatcher(
368                            TelephonyEventLog.TAG_IMS_CONNECTION_STATE, m)));
369        } catch (RemoteException e) {
370            fail(e.toString());
371        }
372
373        mEventLog.writeOnImsConnectionState(
374                TelephonyEventLog.IMS_CONNECTION_STATE_DISCONNECTED,
375                new ImsReasonInfo(1, 2, "test"));
376
377        m.put(TelephonyEventLog.DATA_KEY_PARAM1,
378                TelephonyEventLog.IMS_CONNECTION_STATE_DISCONNECTED);
379        m.put(TelephonyEventLog.DATA_KEY_REASONINFO_CODE, 1);
380        m.put(TelephonyEventLog.DATA_KEY_REASONINFO_EXTRA_CODE, 2);
381        m.put(TelephonyEventLog.DATA_KEY_REASONINFO_EXTRA_MESSAGE, "test");
382
383        try {
384            verify(mConnectivityMetricsLogger).logEvent(
385                    argThat(new TelephonyEventMatcher(
386                            TelephonyEventLog.TAG_IMS_CONNECTION_STATE, m)));
387        } catch (RemoteException e) {
388            fail(e.toString());
389        }
390    }
391}