1/*
2 * Copyright (C) 2008 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.settings;
18
19import android.app.Activity;
20import android.app.AlarmManager;
21import android.app.PendingIntent;
22import android.app.Service;
23import android.app.usage.UsageStatsManager;
24import android.bluetooth.BluetoothAdapter;
25import android.bluetooth.BluetoothPan;
26import android.bluetooth.BluetoothProfile;
27import android.bluetooth.BluetoothProfile.ServiceListener;
28import android.content.BroadcastReceiver;
29import android.content.Context;
30import android.content.Intent;
31import android.content.IntentFilter;
32import android.content.SharedPreferences;
33import android.content.pm.PackageManager;
34import android.content.pm.ResolveInfo;
35import android.net.ConnectivityManager;
36import android.os.IBinder;
37import android.os.ResultReceiver;
38import android.os.SystemClock;
39import android.text.TextUtils;
40import android.util.ArrayMap;
41import android.util.Log;
42
43import com.android.internal.annotations.VisibleForTesting;
44
45import java.util.ArrayList;
46import java.util.List;
47
48public class TetherService extends Service {
49    private static final String TAG = "TetherService";
50    private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
51
52    @VisibleForTesting
53    public static final String EXTRA_RESULT = "EntitlementResult";
54
55    // Activity results to match the activity provision protocol.
56    // Default to something not ok.
57    private static final int RESULT_DEFAULT = Activity.RESULT_CANCELED;
58    private static final int RESULT_OK = Activity.RESULT_OK;
59
60    private static final String TETHER_CHOICE = "TETHER_TYPE";
61    private static final int MS_PER_HOUR = 60 * 60 * 1000;
62
63    private static final String PREFS = "tetherPrefs";
64    private static final String KEY_TETHERS = "currentTethers";
65
66    private int mCurrentTypeIndex;
67    private boolean mInProvisionCheck;
68    private UsageStatsManagerWrapper mUsageManagerWrapper;
69    private ArrayList<Integer> mCurrentTethers;
70    private ArrayMap<Integer, List<ResultReceiver>> mPendingCallbacks;
71    private HotspotOffReceiver mHotspotReceiver;
72
73    @Override
74    public IBinder onBind(Intent intent) {
75        return null;
76    }
77
78    @Override
79    public void onCreate() {
80        super.onCreate();
81        if (DEBUG) Log.d(TAG, "Creating TetherService");
82        String provisionResponse = getResources().getString(
83                com.android.internal.R.string.config_mobile_hotspot_provision_response);
84        registerReceiver(mReceiver, new IntentFilter(provisionResponse),
85                android.Manifest.permission.CONNECTIVITY_INTERNAL, null);
86        SharedPreferences prefs = getSharedPreferences(PREFS, MODE_PRIVATE);
87        mCurrentTethers = stringToTethers(prefs.getString(KEY_TETHERS, ""));
88        mCurrentTypeIndex = 0;
89        mPendingCallbacks = new ArrayMap<>(3);
90        mPendingCallbacks.put(ConnectivityManager.TETHERING_WIFI, new ArrayList<ResultReceiver>());
91        mPendingCallbacks.put(ConnectivityManager.TETHERING_USB, new ArrayList<ResultReceiver>());
92        mPendingCallbacks.put(
93                ConnectivityManager.TETHERING_BLUETOOTH, new ArrayList<ResultReceiver>());
94        if (mUsageManagerWrapper == null) {
95            mUsageManagerWrapper = new UsageStatsManagerWrapper(this);
96        }
97        mHotspotReceiver = new HotspotOffReceiver(this);
98    }
99
100    @Override
101    public int onStartCommand(Intent intent, int flags, int startId) {
102        if (intent.hasExtra(ConnectivityManager.EXTRA_ADD_TETHER_TYPE)) {
103            int type = intent.getIntExtra(ConnectivityManager.EXTRA_ADD_TETHER_TYPE,
104                    ConnectivityManager.TETHERING_INVALID);
105            ResultReceiver callback =
106                    intent.getParcelableExtra(ConnectivityManager.EXTRA_PROVISION_CALLBACK);
107            if (callback != null) {
108                List<ResultReceiver> callbacksForType = mPendingCallbacks.get(type);
109                if (callbacksForType != null) {
110                    callbacksForType.add(callback);
111                } else {
112                    // Invalid tether type. Just ignore this request and report failure.
113                    callback.send(ConnectivityManager.TETHER_ERROR_UNKNOWN_IFACE, null);
114                    stopSelf();
115                    return START_NOT_STICKY;
116                }
117            }
118
119            if (!mCurrentTethers.contains(type)) {
120                if (DEBUG) Log.d(TAG, "Adding tether " + type);
121                mCurrentTethers.add(type);
122            }
123        }
124
125        if (intent.hasExtra(ConnectivityManager.EXTRA_REM_TETHER_TYPE)) {
126            if (!mInProvisionCheck) {
127                int type = intent.getIntExtra(ConnectivityManager.EXTRA_REM_TETHER_TYPE,
128                        ConnectivityManager.TETHERING_INVALID);
129                int index = mCurrentTethers.indexOf(type);
130                if (DEBUG) Log.d(TAG, "Removing tether " + type + ", index " + index);
131                if (index >= 0) {
132                    removeTypeAtIndex(index);
133                }
134                cancelAlarmIfNecessary();
135            } else {
136                if (DEBUG) Log.d(TAG, "Don't cancel alarm during provisioning");
137            }
138        }
139
140        // Only set the alarm if we have one tether, meaning the one just added,
141        // to avoid setting it when it was already set previously for another
142        // type.
143        if (intent.getBooleanExtra(ConnectivityManager.EXTRA_SET_ALARM, false)
144                && mCurrentTethers.size() == 1) {
145            scheduleAlarm();
146        }
147
148        if (intent.getBooleanExtra(ConnectivityManager.EXTRA_RUN_PROVISION, false)) {
149            startProvisioning(mCurrentTypeIndex);
150        } else if (!mInProvisionCheck) {
151            // If we aren't running any provisioning, no reason to stay alive.
152            if (DEBUG) Log.d(TAG, "Stopping self.  startid: " + startId);
153            stopSelf();
154            return START_NOT_STICKY;
155        }
156        // We want to be started if we are killed accidently, so that we can be sure we finish
157        // the check.
158        return START_REDELIVER_INTENT;
159    }
160
161    @Override
162    public void onDestroy() {
163        if (mInProvisionCheck) {
164            Log.e(TAG, "TetherService getting destroyed while mid-provisioning"
165                    + mCurrentTethers.get(mCurrentTypeIndex));
166        }
167        SharedPreferences prefs = getSharedPreferences(PREFS, MODE_PRIVATE);
168        prefs.edit().putString(KEY_TETHERS, tethersToString(mCurrentTethers)).commit();
169
170        if (DEBUG) Log.d(TAG, "Destroying TetherService");
171        unregisterReceiver(mReceiver);
172        super.onDestroy();
173    }
174
175    private void removeTypeAtIndex(int index) {
176        mCurrentTethers.remove(index);
177        // If we are currently in the middle of a check, we may need to adjust the
178        // index accordingly.
179        if (DEBUG) Log.d(TAG, "mCurrentTypeIndex: " + mCurrentTypeIndex);
180        if (index <= mCurrentTypeIndex && mCurrentTypeIndex > 0) {
181            mCurrentTypeIndex--;
182        }
183    }
184
185    @VisibleForTesting
186    void setHotspotOffReceiver(HotspotOffReceiver receiver) {
187        mHotspotReceiver = receiver;
188    }
189
190    private ArrayList<Integer> stringToTethers(String tethersStr) {
191        ArrayList<Integer> ret = new ArrayList<Integer>();
192        if (TextUtils.isEmpty(tethersStr)) return ret;
193
194        String[] tethersSplit = tethersStr.split(",");
195        for (int i = 0; i < tethersSplit.length; i++) {
196            ret.add(Integer.parseInt(tethersSplit[i]));
197        }
198        return ret;
199    }
200
201    private String tethersToString(ArrayList<Integer> tethers) {
202        final StringBuffer buffer = new StringBuffer();
203        final int N = tethers.size();
204        for (int i = 0; i < N; i++) {
205            if (i != 0) {
206                buffer.append(',');
207            }
208            buffer.append(tethers.get(i));
209        }
210
211        return buffer.toString();
212    }
213
214    private void disableWifiTethering() {
215        ConnectivityManager cm =
216                (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
217        cm.stopTethering(ConnectivityManager.TETHERING_WIFI);
218    }
219
220    private void disableUsbTethering() {
221        ConnectivityManager cm =
222                (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
223        cm.setUsbTethering(false);
224    }
225
226    private void disableBtTethering() {
227        final BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
228        if (adapter != null) {
229            adapter.getProfileProxy(this, new ServiceListener() {
230                @Override
231                public void onServiceDisconnected(int profile) { }
232
233                @Override
234                public void onServiceConnected(int profile, BluetoothProfile proxy) {
235                    ((BluetoothPan) proxy).setBluetoothTethering(false);
236                    adapter.closeProfileProxy(BluetoothProfile.PAN, proxy);
237                }
238            }, BluetoothProfile.PAN);
239        }
240    }
241
242    private void startProvisioning(int index) {
243        if (index < mCurrentTethers.size()) {
244            Intent intent = getProvisionBroadcastIntent(index);
245            setEntitlementAppActive(index);
246
247            if (DEBUG) Log.d(TAG, "Sending provisioning broadcast: " + intent.getAction()
248                    + " type: " + mCurrentTethers.get(index));
249
250            sendBroadcast(intent);
251            mInProvisionCheck = true;
252        }
253    }
254
255    private Intent getProvisionBroadcastIntent(int index) {
256        String provisionAction = getResources().getString(
257                com.android.internal.R.string.config_mobile_hotspot_provision_app_no_ui);
258        Intent intent = new Intent(provisionAction);
259        int type = mCurrentTethers.get(index);
260        intent.putExtra(TETHER_CHOICE, type);
261        intent.setFlags(Intent.FLAG_RECEIVER_FOREGROUND
262                | Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND);
263
264        return intent;
265    }
266
267    private void setEntitlementAppActive(int index) {
268        final PackageManager packageManager = getPackageManager();
269        Intent intent = getProvisionBroadcastIntent(index);
270        List<ResolveInfo> resolvers =
271                packageManager.queryBroadcastReceivers(intent, PackageManager.MATCH_ALL);
272        if (resolvers.isEmpty()) {
273            Log.e(TAG, "No found BroadcastReceivers for provision intent.");
274            return;
275        }
276
277        for (ResolveInfo resolver : resolvers) {
278            if (resolver.activityInfo.applicationInfo.isSystemApp()) {
279                String packageName = resolver.activityInfo.packageName;
280                mUsageManagerWrapper.setAppInactive(packageName, false);
281            }
282        }
283    }
284
285    @VisibleForTesting
286    void scheduleAlarm() {
287        Intent intent = new Intent(this, TetherService.class);
288        intent.putExtra(ConnectivityManager.EXTRA_RUN_PROVISION, true);
289
290        PendingIntent pendingIntent = PendingIntent.getService(this, 0, intent, 0);
291        AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
292        int period = getResources().getInteger(
293                com.android.internal.R.integer.config_mobile_hotspot_provision_check_period);
294        long periodMs = period * MS_PER_HOUR;
295        long firstTime = SystemClock.elapsedRealtime() + periodMs;
296        if (DEBUG) Log.d(TAG, "Scheduling alarm at interval " + periodMs);
297        alarmManager.setRepeating(AlarmManager.ELAPSED_REALTIME, firstTime, periodMs,
298                pendingIntent);
299        mHotspotReceiver.register();
300    }
301
302    /**
303     * Cancels the recheck alarm only if no tethering is currently active.
304     *
305     * Runs in the background, to get access to bluetooth service that takes time to bind.
306     */
307    public static void cancelRecheckAlarmIfNecessary(final Context context, int type) {
308        Intent intent = new Intent(context, TetherService.class);
309        intent.putExtra(ConnectivityManager.EXTRA_REM_TETHER_TYPE, type);
310        context.startService(intent);
311    }
312
313    @VisibleForTesting
314    void cancelAlarmIfNecessary() {
315        if (mCurrentTethers.size() != 0) {
316            if (DEBUG) Log.d(TAG, "Tethering still active, not cancelling alarm");
317            return;
318        }
319        Intent intent = new Intent(this, TetherService.class);
320        PendingIntent pendingIntent = PendingIntent.getService(this, 0, intent, 0);
321        AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
322        alarmManager.cancel(pendingIntent);
323        if (DEBUG) Log.d(TAG, "Tethering no longer active, canceling recheck");
324        mHotspotReceiver.unregister();
325    }
326
327    private void fireCallbacksForType(int type, int result) {
328        List<ResultReceiver> callbacksForType = mPendingCallbacks.get(type);
329        if (callbacksForType == null) {
330            return;
331        }
332        int errorCode = result == RESULT_OK ? ConnectivityManager.TETHER_ERROR_NO_ERROR :
333                ConnectivityManager.TETHER_ERROR_PROVISION_FAILED;
334        for (ResultReceiver callback : callbacksForType) {
335          if (DEBUG) Log.d(TAG, "Firing result: " + errorCode + " to callback");
336          callback.send(errorCode, null);
337        }
338        callbacksForType.clear();
339    }
340
341    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
342        @Override
343        public void onReceive(Context context, Intent intent) {
344            if (DEBUG) Log.d(TAG, "Got provision result " + intent);
345            String provisionResponse = getResources().getString(
346                    com.android.internal.R.string.config_mobile_hotspot_provision_response);
347
348            if (provisionResponse.equals(intent.getAction())) {
349                if (!mInProvisionCheck) {
350                    Log.e(TAG, "Unexpected provision response " + intent);
351                    return;
352                }
353                int checkType = mCurrentTethers.get(mCurrentTypeIndex);
354                mInProvisionCheck = false;
355                int result = intent.getIntExtra(EXTRA_RESULT, RESULT_DEFAULT);
356                if (result != RESULT_OK) {
357                    switch (checkType) {
358                        case ConnectivityManager.TETHERING_WIFI:
359                            disableWifiTethering();
360                            break;
361                        case ConnectivityManager.TETHERING_BLUETOOTH:
362                            disableBtTethering();
363                            break;
364                        case ConnectivityManager.TETHERING_USB:
365                            disableUsbTethering();
366                            break;
367                    }
368                }
369                fireCallbacksForType(checkType, result);
370
371                if (++mCurrentTypeIndex >= mCurrentTethers.size()) {
372                    // We are done with all checks, time to die.
373                    stopSelf();
374                } else {
375                    // Start the next check in our list.
376                    startProvisioning(mCurrentTypeIndex);
377                }
378            }
379        }
380    };
381
382    @VisibleForTesting
383    void setUsageStatsManagerWrapper(UsageStatsManagerWrapper wrapper) {
384        mUsageManagerWrapper = wrapper;
385    }
386
387    /**
388     * A static helper class used for tests. UsageStatsManager cannot be mocked out becasue
389     * it's marked final. This class can be mocked out instead.
390     */
391    @VisibleForTesting
392    public static class UsageStatsManagerWrapper {
393        private final UsageStatsManager mUsageStatsManager;
394
395        UsageStatsManagerWrapper(Context context) {
396            mUsageStatsManager = (UsageStatsManager)
397                    context.getSystemService(Context.USAGE_STATS_SERVICE);
398        }
399
400        void setAppInactive(String packageName, boolean isInactive) {
401            mUsageStatsManager.setAppInactive(packageName, isInactive);
402        }
403    }
404}
405