1 /*
2  * Copyright (C) 2017 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 com.googlecode.android_scripting.facade.telephony;
18 
19 import android.os.Looper;
20 import android.telephony.CellInfo;
21 import android.telephony.DataConnectionRealTimeInfo;
22 import android.telephony.PhoneStateListener;
23 import android.telephony.PhysicalChannelConfig;
24 import android.telephony.PreciseCallState;
25 import android.telephony.ServiceState;
26 import android.telephony.SignalStrength;
27 import android.telephony.SubscriptionManager;
28 import android.telephony.TelephonyManager;
29 
30 import com.googlecode.android_scripting.facade.EventFacade;
31 
32 import java.util.List;
33 
34 /**
35  * Store all subclasses of PhoneStateListener here.
36  */
37 public class TelephonyStateListeners {
38 
39     public static class CallStateChangeListener extends PhoneStateListener {
40 
41         private final EventFacade mEventFacade;
42         public static final int sListeningStates = PhoneStateListener.LISTEN_CALL_STATE |
43                                                    PhoneStateListener.LISTEN_PRECISE_CALL_STATE;
44 
45         public boolean listenForeground = true;
46         public boolean listenRinging = false;
47         public boolean listenBackground = false;
48         public int subscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
49 
CallStateChangeListener(EventFacade ef)50         public CallStateChangeListener(EventFacade ef) {
51             super();
52             mEventFacade = ef;
53             subscriptionId = SubscriptionManager.DEFAULT_SUBSCRIPTION_ID;
54         }
55 
CallStateChangeListener(EventFacade ef, int subId)56         public CallStateChangeListener(EventFacade ef, int subId) {
57             super();
58             mEventFacade = ef;
59             subscriptionId = subId;
60         }
61 
CallStateChangeListener(EventFacade ef, int subId, Looper looper)62         public CallStateChangeListener(EventFacade ef, int subId, Looper looper) {
63             super(looper);
64             mEventFacade = ef;
65             subscriptionId = subId;
66         }
67 
68         @Override
onCallStateChanged(int state, String incomingNumber)69         public void onCallStateChanged(int state, String incomingNumber) {
70             mEventFacade.postEvent(TelephonyConstants.EventCallStateChanged,
71                 new TelephonyEvents.CallStateEvent(
72                     state, incomingNumber, subscriptionId));
73         }
74 
75         @Override
onPreciseCallStateChanged(PreciseCallState callState)76         public void onPreciseCallStateChanged(PreciseCallState callState) {
77             int foregroundState = callState.getForegroundCallState();
78             int ringingState = callState.getRingingCallState();
79             int backgroundState = callState.getBackgroundCallState();
80             if (listenForeground &&
81                 foregroundState != PreciseCallState.PRECISE_CALL_STATE_NOT_VALID) {
82                 processCallState(foregroundState,
83                         TelephonyConstants.PRECISE_CALL_STATE_LISTEN_LEVEL_FOREGROUND,
84                         callState);
85             }
86             if (listenRinging &&
87                 ringingState != PreciseCallState.PRECISE_CALL_STATE_NOT_VALID) {
88                 processCallState(ringingState,
89                         TelephonyConstants.PRECISE_CALL_STATE_LISTEN_LEVEL_RINGING,
90                         callState);
91             }
92             if (listenBackground &&
93                 backgroundState != PreciseCallState.PRECISE_CALL_STATE_NOT_VALID) {
94                 processCallState(backgroundState,
95                         TelephonyConstants.PRECISE_CALL_STATE_LISTEN_LEVEL_BACKGROUND,
96                         callState);
97             }
98         }
99 
processCallState( int newState, String which, PreciseCallState callState)100         private void processCallState(
101             int newState, String which, PreciseCallState callState) {
102             mEventFacade.postEvent(TelephonyConstants.EventPreciseStateChanged,
103                 new TelephonyEvents.PreciseCallStateEvent(
104                     newState, which, callState, subscriptionId));
105         }
106     }
107 
108     public static class DataConnectionRealTimeInfoChangeListener extends PhoneStateListener {
109 
110         private final EventFacade mEventFacade;
111         public static final int sListeningStates =
112                 PhoneStateListener.LISTEN_DATA_CONNECTION_REAL_TIME_INFO;
113         public int subscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
114 
DataConnectionRealTimeInfoChangeListener(EventFacade ef)115         public DataConnectionRealTimeInfoChangeListener(EventFacade ef) {
116             super();
117             mEventFacade = ef;
118             subscriptionId = SubscriptionManager.DEFAULT_SUBSCRIPTION_ID;
119         }
120 
DataConnectionRealTimeInfoChangeListener(EventFacade ef, int subId)121         public DataConnectionRealTimeInfoChangeListener(EventFacade ef, int subId) {
122             super();
123             mEventFacade = ef;
124             subscriptionId = subId;
125         }
126 
DataConnectionRealTimeInfoChangeListener(EventFacade ef, int subId, Looper looper)127         public DataConnectionRealTimeInfoChangeListener(EventFacade ef, int subId, Looper looper) {
128             super(looper);
129             mEventFacade = ef;
130             subscriptionId = subId;
131         }
132 
133         @Override
onDataConnectionRealTimeInfoChanged( DataConnectionRealTimeInfo dcRtInfo)134         public void onDataConnectionRealTimeInfoChanged(
135             DataConnectionRealTimeInfo dcRtInfo) {
136             mEventFacade.postEvent(
137                 TelephonyConstants.EventDataConnectionRealTimeInfoChanged,
138                 new TelephonyEvents.DataConnectionRealTimeInfoEvent(
139                     dcRtInfo, subscriptionId));
140         }
141     }
142 
143     public static class DataConnectionStateChangeListener extends PhoneStateListener {
144 
145         private final EventFacade mEventFacade;
146         private final TelephonyManager mTelephonyManager;
147         public static final int sListeningStates =
148                 PhoneStateListener.LISTEN_DATA_CONNECTION_STATE;
149         public int subscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
150 
DataConnectionStateChangeListener(EventFacade ef, TelephonyManager tm)151         public DataConnectionStateChangeListener(EventFacade ef, TelephonyManager tm) {
152             super();
153             mEventFacade = ef;
154             mTelephonyManager = tm;
155             subscriptionId = SubscriptionManager.DEFAULT_SUBSCRIPTION_ID;
156         }
157 
DataConnectionStateChangeListener(EventFacade ef, TelephonyManager tm, int subId)158         public DataConnectionStateChangeListener(EventFacade ef, TelephonyManager tm, int subId) {
159             super();
160             mEventFacade = ef;
161             mTelephonyManager = tm;
162             subscriptionId = subId;
163         }
164 
DataConnectionStateChangeListener( EventFacade ef, TelephonyManager tm, int subId, Looper looper)165         public DataConnectionStateChangeListener(
166                 EventFacade ef, TelephonyManager tm, int subId, Looper looper) {
167             super(looper);
168             mEventFacade = ef;
169             mTelephonyManager = tm;
170             subscriptionId = subId;
171         }
172 
173         @Override
onDataConnectionStateChanged(int state)174         public void onDataConnectionStateChanged(int state) {
175             mEventFacade.postEvent(
176                 TelephonyConstants.EventDataConnectionStateChanged,
177                 new TelephonyEvents.DataConnectionStateEvent(state,
178                     TelephonyUtils.getNetworkTypeString(
179                                  mTelephonyManager.getDataNetworkType()),
180                     subscriptionId));
181         }
182     }
183 
184     public static class ActiveDataSubIdChangeListener extends PhoneStateListener {
185 
186         private final EventFacade mEventFacade;
187         private final TelephonyManager mTelephonyManager;
188         public static final int sListeningStates =
189                 PhoneStateListener.LISTEN_ACTIVE_DATA_SUBSCRIPTION_ID_CHANGE;
190         public int subscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
191 
ActiveDataSubIdChangeListener(EventFacade ef, TelephonyManager tm)192         public ActiveDataSubIdChangeListener(EventFacade ef, TelephonyManager tm) {
193             super();
194             mEventFacade = ef;
195             mTelephonyManager = tm;
196             subscriptionId = SubscriptionManager.DEFAULT_SUBSCRIPTION_ID;
197         }
198 
ActiveDataSubIdChangeListener(EventFacade ef, TelephonyManager tm, int subId)199         public ActiveDataSubIdChangeListener(EventFacade ef, TelephonyManager tm, int subId) {
200             super();
201             mEventFacade = ef;
202             mTelephonyManager = tm;
203             subscriptionId = subId;
204         }
205 
ActiveDataSubIdChangeListener( EventFacade ef, TelephonyManager tm, int subId, Looper looper)206         public ActiveDataSubIdChangeListener(
207                 EventFacade ef, TelephonyManager tm, int subId, Looper looper) {
208             super(looper);
209             mEventFacade = ef;
210             mTelephonyManager = tm;
211             subscriptionId = subId;
212         }
213 
214         @Override
onActiveDataSubscriptionIdChanged(int subId)215         public void onActiveDataSubscriptionIdChanged(int subId) {
216             mEventFacade.postEvent(
217                 TelephonyConstants.EventActiveDataSubIdChanged, subId);
218         }
219     }
220 
221     public static class ServiceStateChangeListener extends PhoneStateListener {
222 
223         private final EventFacade mEventFacade;
224         public static final int sListeningStates = PhoneStateListener.LISTEN_SERVICE_STATE;
225         public int subscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
226 
ServiceStateChangeListener(EventFacade ef)227         public ServiceStateChangeListener(EventFacade ef) {
228             super();
229             mEventFacade = ef;
230             subscriptionId = SubscriptionManager.DEFAULT_SUBSCRIPTION_ID;
231         }
232 
ServiceStateChangeListener(EventFacade ef, int subId)233         public ServiceStateChangeListener(EventFacade ef, int subId) {
234             super();
235             mEventFacade = ef;
236             subscriptionId = subId;
237         }
238 
ServiceStateChangeListener(EventFacade ef, int subId, Looper looper)239         public ServiceStateChangeListener(EventFacade ef, int subId, Looper looper) {
240             super(looper);
241             mEventFacade = ef;
242             subscriptionId = subId;
243         }
244 
245         @Override
onServiceStateChanged(ServiceState serviceState)246         public void onServiceStateChanged(ServiceState serviceState) {
247             mEventFacade.postEvent(TelephonyConstants.EventServiceStateChanged,
248                 new TelephonyEvents.ServiceStateEvent(
249                     serviceState, subscriptionId));
250         }
251 
252     }
253 
254     public static class CellInfoChangeListener
255             extends PhoneStateListener {
256 
257         private final EventFacade mEventFacade;
258 
CellInfoChangeListener(EventFacade ef)259         public CellInfoChangeListener(EventFacade ef) {
260             super();
261             mEventFacade = ef;
262         }
263 
CellInfoChangeListener(EventFacade ef, int subId)264         public CellInfoChangeListener(EventFacade ef, int subId) {
265             super();
266             mEventFacade = ef;
267         }
268 
CellInfoChangeListener(EventFacade ef, int subId, Looper looper)269         public CellInfoChangeListener(EventFacade ef, int subId, Looper looper) {
270             super(looper);
271             mEventFacade = ef;
272         }
273 
274         @Override
onCellInfoChanged(List<CellInfo> cellInfo)275         public void onCellInfoChanged(List<CellInfo> cellInfo) {
276             mEventFacade.postEvent(
277                 TelephonyConstants.EventCellInfoChanged, cellInfo);
278         }
279     }
280 
281     public static class SrvccStateChangeListener
282             extends PhoneStateListener {
283 
284         private final EventFacade mEventFacade;
285 
SrvccStateChangeListener(EventFacade ef)286         public SrvccStateChangeListener(EventFacade ef) {
287             super();
288             mEventFacade = ef;
289         }
290 
SrvccStateChangeListener(EventFacade ef, int subId)291         public SrvccStateChangeListener(EventFacade ef, int subId) {
292             super();
293             mEventFacade = ef;
294         }
295 
SrvccStateChangeListener(EventFacade ef, int subId, Looper looper)296         public SrvccStateChangeListener(EventFacade ef, int subId, Looper looper) {
297             super(looper);
298             mEventFacade = ef;
299         }
300 
301         @Override
onSrvccStateChanged(int srvccState)302         public void onSrvccStateChanged(int srvccState) {
303             mEventFacade.postEvent(
304                     TelephonyConstants.EventSrvccStateChanged,
305                     srvccState);
306         }
307     }
308 
309     public static class VoiceMailStateChangeListener extends PhoneStateListener {
310 
311         private final EventFacade mEventFacade;
312 
313         public static final int sListeningStates =
314                 PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR;
315 
VoiceMailStateChangeListener(EventFacade ef)316         public VoiceMailStateChangeListener(EventFacade ef) {
317             super();
318             mEventFacade = ef;
319         }
320 
VoiceMailStateChangeListener(EventFacade ef, int subId)321         public VoiceMailStateChangeListener(EventFacade ef, int subId) {
322             super();
323             mEventFacade = ef;
324         }
325 
VoiceMailStateChangeListener(EventFacade ef, int subId, Looper looper)326         public VoiceMailStateChangeListener(EventFacade ef, int subId, Looper looper) {
327             super(looper);
328             mEventFacade = ef;
329         }
330 
331         @Override
onMessageWaitingIndicatorChanged(boolean messageWaitingIndicator)332         public void onMessageWaitingIndicatorChanged(boolean messageWaitingIndicator) {
333             mEventFacade.postEvent(
334                     TelephonyConstants.EventMessageWaitingIndicatorChanged,
335                     new TelephonyEvents.MessageWaitingIndicatorEvent(
336                         messageWaitingIndicator));
337         }
338     }
339 
340 
341     public static class SignalStrengthChangeListener extends PhoneStateListener {
342 
343         private final EventFacade mEventFacade;
344         public SignalStrength mSignalStrengths;
345         public static final int sListeningStates = PhoneStateListener.LISTEN_SIGNAL_STRENGTHS;
SignalStrengthChangeListener(EventFacade ef)346         public SignalStrengthChangeListener(EventFacade ef) {
347             super();
348             mEventFacade = ef;
349         }
350 
SignalStrengthChangeListener(EventFacade ef, int subId)351         public SignalStrengthChangeListener(EventFacade ef, int subId) {
352             super();
353             mEventFacade = ef;
354         }
355 
SignalStrengthChangeListener(EventFacade ef, int subId, Looper looper)356         public SignalStrengthChangeListener(EventFacade ef, int subId, Looper looper) {
357             super(looper);
358             mEventFacade = ef;
359         }
360 
361         @Override
onSignalStrengthsChanged(SignalStrength signalStrength)362         public void onSignalStrengthsChanged(SignalStrength signalStrength) {
363             mSignalStrengths = signalStrength;
364             mEventFacade.postEvent(
365                 TelephonyConstants.EventSignalStrengthChanged, signalStrength);
366         }
367     }
368 
369     public static class PhysicalChannelConfigurationChangeListener extends PhoneStateListener {
370 
371         private final EventFacade mEventFacade;
372         public List<PhysicalChannelConfig> mConfigs;
373         public static final int sListeningStates =
374                 PhoneStateListener.LISTEN_PHYSICAL_CHANNEL_CONFIGURATION;
PhysicalChannelConfigurationChangeListener(EventFacade ef)375         public PhysicalChannelConfigurationChangeListener(EventFacade ef) {
376             super();
377             mEventFacade = ef;
378         }
379 
PhysicalChannelConfigurationChangeListener(EventFacade ef, int subId)380         public PhysicalChannelConfigurationChangeListener(EventFacade ef, int subId) {
381             super();
382             mEventFacade = ef;
383         }
384 
PhysicalChannelConfigurationChangeListener( EventFacade ef, int subId, Looper looper)385         public PhysicalChannelConfigurationChangeListener(
386                 EventFacade ef, int subId, Looper looper) {
387             super(looper);
388             mEventFacade = ef;
389         }
390 
391         @Override
onPhysicalChannelConfigurationChanged(List<PhysicalChannelConfig> config)392         public void onPhysicalChannelConfigurationChanged(List<PhysicalChannelConfig> config) {
393             mEventFacade.postEvent(
394                 TelephonyConstants.EventPhysicalChannelConfigChanged, config);
395         }
396     }
397 
398 }
399