| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.server; |
| |
| import android.app.AlarmManager; |
| import android.app.Notification; |
| import android.app.NotificationManager; |
| import android.app.PendingIntent; |
| import android.content.BroadcastReceiver; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.pm.PackageManager; |
| import android.content.res.Resources; |
| import android.database.ContentObserver; |
| import android.net.INetworkManagementEventObserver; |
| import android.net.IThrottleManager; |
| import android.net.SntpClient; |
| import android.net.ThrottleManager; |
| import android.os.Binder; |
| import android.os.Environment; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.IBinder; |
| import android.os.INetworkManagementService; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.RemoteException; |
| import android.os.ServiceManager; |
| import android.os.SystemClock; |
| import android.os.SystemProperties; |
| import android.provider.Settings; |
| import android.telephony.TelephonyManager; |
| import android.text.TextUtils; |
| import android.util.Slog; |
| |
| import com.android.internal.R; |
| import com.android.internal.telephony.TelephonyProperties; |
| |
| import java.io.BufferedWriter; |
| import java.io.File; |
| import java.io.FileDescriptor; |
| import java.io.FileInputStream; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.util.Calendar; |
| import java.util.GregorianCalendar; |
| import java.util.Properties; |
| import java.util.Random; |
| |
| // TODO - add comments - reference the ThrottleManager for public API |
| public class ThrottleService extends IThrottleManager.Stub { |
| |
| private static final String TESTING_ENABLED_PROPERTY = "persist.throttle.testing"; |
| |
| private static final String TAG = "ThrottleService"; |
| private static final boolean DBG = true; |
| private static final boolean VDBG = false; |
| private Handler mHandler; |
| private HandlerThread mThread; |
| |
| private Context mContext; |
| |
| private static final int INITIAL_POLL_DELAY_SEC = 90; |
| private static final int TESTING_POLLING_PERIOD_SEC = 60 * 1; |
| private static final int TESTING_RESET_PERIOD_SEC = 60 * 10; |
| private static final long TESTING_THRESHOLD = 1 * 1024 * 1024; |
| |
| private int mPolicyPollPeriodSec; |
| private long mPolicyThreshold; |
| private int mPolicyThrottleValue; |
| private int mPolicyResetDay; // 1-28 |
| private int mPolicyNotificationsAllowedMask; |
| |
| private long mLastRead; // read byte count from last poll |
| private long mLastWrite; // write byte count from last poll |
| |
| private static final String ACTION_POLL = "com.android.server.ThrottleManager.action.POLL"; |
| private static int POLL_REQUEST = 0; |
| private PendingIntent mPendingPollIntent; |
| private static final String ACTION_RESET = "com.android.server.ThorottleManager.action.RESET"; |
| private static int RESET_REQUEST = 1; |
| private PendingIntent mPendingResetIntent; |
| |
| private INetworkManagementService mNMService; |
| private AlarmManager mAlarmManager; |
| private NotificationManager mNotificationManager; |
| |
| private DataRecorder mRecorder; |
| |
| private String mIface; |
| |
| private static final int NOTIFICATION_WARNING = 2; |
| |
| private Notification mThrottlingNotification; |
| private boolean mWarningNotificationSent = false; |
| |
| private InterfaceObserver mInterfaceObserver; |
| private SettingsObserver mSettingsObserver; |
| |
| private int mThrottleIndex; // 0 for none, 1 for first throttle val, 2 for next, etc |
| private static final int THROTTLE_INDEX_UNINITIALIZED = -1; |
| private static final int THROTTLE_INDEX_UNTHROTTLED = 0; |
| |
| private static final String PROPERTIES_FILE = "/etc/gps.conf"; |
| private String mNtpServer; |
| private boolean mNtpActive; |
| |
| public ThrottleService(Context context) { |
| if (VDBG) Slog.v(TAG, "Starting ThrottleService"); |
| mContext = context; |
| |
| mNtpActive = false; |
| |
| mIface = mContext.getResources().getString(R.string.config_datause_iface); |
| mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE); |
| Intent pollIntent = new Intent(ACTION_POLL, null); |
| mPendingPollIntent = PendingIntent.getBroadcast(mContext, POLL_REQUEST, pollIntent, 0); |
| Intent resetIntent = new Intent(ACTION_RESET, null); |
| mPendingResetIntent = PendingIntent.getBroadcast(mContext, RESET_REQUEST, resetIntent, 0); |
| |
| IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE); |
| mNMService = INetworkManagementService.Stub.asInterface(b); |
| |
| mNotificationManager = (NotificationManager)mContext.getSystemService( |
| Context.NOTIFICATION_SERVICE); |
| } |
| |
| private static class InterfaceObserver extends INetworkManagementEventObserver.Stub { |
| private int mMsg; |
| private Handler mHandler; |
| private String mIface; |
| |
| InterfaceObserver(Handler handler, int msg, String iface) { |
| super(); |
| mHandler = handler; |
| mMsg = msg; |
| mIface = iface; |
| } |
| |
| public void interfaceLinkStatusChanged(String iface, boolean link) { |
| if (link) { |
| if (TextUtils.equals(iface, mIface)) { |
| mHandler.obtainMessage(mMsg).sendToTarget(); |
| } |
| } |
| } |
| |
| public void interfaceAdded(String iface) { |
| // TODO - an interface added in the UP state should also trigger a StatusChanged |
| // notification.. |
| if (TextUtils.equals(iface, mIface)) { |
| mHandler.obtainMessage(mMsg).sendToTarget(); |
| } |
| } |
| |
| public void interfaceRemoved(String iface) {} |
| } |
| |
| |
| private static class SettingsObserver extends ContentObserver { |
| private int mMsg; |
| private Handler mHandler; |
| SettingsObserver(Handler handler, int msg) { |
| super(handler); |
| mHandler = handler; |
| mMsg = msg; |
| } |
| |
| void observe(Context context) { |
| ContentResolver resolver = context.getContentResolver(); |
| resolver.registerContentObserver(Settings.Secure.getUriFor( |
| Settings.Secure.THROTTLE_POLLING_SEC), false, this); |
| resolver.registerContentObserver(Settings.Secure.getUriFor( |
| Settings.Secure.THROTTLE_THRESHOLD_BYTES), false, this); |
| resolver.registerContentObserver(Settings.Secure.getUriFor( |
| Settings.Secure.THROTTLE_VALUE_KBITSPS), false, this); |
| resolver.registerContentObserver(Settings.Secure.getUriFor( |
| Settings.Secure.THROTTLE_RESET_DAY), false, this); |
| resolver.registerContentObserver(Settings.Secure.getUriFor( |
| Settings.Secure.THROTTLE_NOTIFICATION_TYPE), false, this); |
| resolver.registerContentObserver(Settings.Secure.getUriFor( |
| Settings.Secure.THROTTLE_HELP_URI), false, this); |
| resolver.registerContentObserver(Settings.Secure.getUriFor( |
| Settings.Secure.THROTTLE_MAX_NTP_CACHE_AGE_SEC), false, this); |
| } |
| |
| @Override |
| public void onChange(boolean selfChange) { |
| mHandler.obtainMessage(mMsg).sendToTarget(); |
| } |
| } |
| |
| private void enforceAccessPermission() { |
| mContext.enforceCallingOrSelfPermission( |
| android.Manifest.permission.ACCESS_NETWORK_STATE, |
| "ThrottleService"); |
| } |
| |
| private long ntpToWallTime(long ntpTime) { |
| long bestNow = getBestTime(); |
| long localNow = System.currentTimeMillis(); |
| return localNow + (ntpTime - bestNow); |
| } |
| |
| // TODO - fetch for the iface |
| // return time in the local, system wall time, correcting for the use of ntp |
| |
| public synchronized long getResetTime(String iface) { |
| enforceAccessPermission(); |
| long resetTime = 0; |
| if (mRecorder != null) { |
| resetTime = ntpToWallTime(mRecorder.getPeriodEnd()); |
| } |
| return resetTime; |
| } |
| |
| // TODO - fetch for the iface |
| // return time in the local, system wall time, correcting for the use of ntp |
| public synchronized long getPeriodStartTime(String iface) { |
| enforceAccessPermission(); |
| long startTime = 0; |
| if (mRecorder != null) { |
| startTime = ntpToWallTime(mRecorder.getPeriodStart()); |
| } |
| return startTime; |
| } |
| //TODO - a better name? getCliffByteCountThreshold? |
| // TODO - fetch for the iface |
| public synchronized long getCliffThreshold(String iface, int cliff) { |
| enforceAccessPermission(); |
| if (cliff == 1) { |
| return mPolicyThreshold; |
| } |
| return 0; |
| } |
| // TODO - a better name? getThrottleRate? |
| // TODO - fetch for the iface |
| public synchronized int getCliffLevel(String iface, int cliff) { |
| enforceAccessPermission(); |
| if (cliff == 1) { |
| return mPolicyThrottleValue; |
| } |
| return 0; |
| } |
| |
| public String getHelpUri() { |
| enforceAccessPermission(); |
| return Settings.Secure.getString(mContext.getContentResolver(), |
| Settings.Secure.THROTTLE_HELP_URI); |
| } |
| |
| // TODO - fetch for the iface |
| public synchronized long getByteCount(String iface, int dir, int period, int ago) { |
| enforceAccessPermission(); |
| if ((period == ThrottleManager.PERIOD_CYCLE) && |
| (mRecorder != null)) { |
| if (dir == ThrottleManager.DIRECTION_TX) return mRecorder.getPeriodTx(ago); |
| if (dir == ThrottleManager.DIRECTION_RX) return mRecorder.getPeriodRx(ago); |
| } |
| return 0; |
| } |
| |
| // TODO - a better name - getCurrentThrottleRate? |
| // TODO - fetch for the iface |
| public synchronized int getThrottle(String iface) { |
| enforceAccessPermission(); |
| if (mThrottleIndex == 1) { |
| return mPolicyThrottleValue; |
| } |
| return 0; |
| } |
| |
| void systemReady() { |
| if (VDBG) Slog.v(TAG, "systemReady"); |
| mContext.registerReceiver( |
| new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| mHandler.obtainMessage(EVENT_POLL_ALARM).sendToTarget(); |
| } |
| }, new IntentFilter(ACTION_POLL)); |
| |
| mContext.registerReceiver( |
| new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| mHandler.obtainMessage(EVENT_RESET_ALARM).sendToTarget(); |
| } |
| }, new IntentFilter(ACTION_RESET)); |
| |
| // use a new thread as we don't want to stall the system for file writes |
| mThread = new HandlerThread(TAG); |
| mThread.start(); |
| mHandler = new MyHandler(mThread.getLooper()); |
| mHandler.obtainMessage(EVENT_REBOOT_RECOVERY).sendToTarget(); |
| |
| mInterfaceObserver = new InterfaceObserver(mHandler, EVENT_IFACE_UP, mIface); |
| try { |
| mNMService.registerObserver(mInterfaceObserver); |
| } catch (RemoteException e) { |
| Slog.e(TAG, "Could not register InterfaceObserver " + e); |
| } |
| |
| mSettingsObserver = new SettingsObserver(mHandler, EVENT_POLICY_CHANGED); |
| mSettingsObserver.observe(mContext); |
| |
| FileInputStream stream = null; |
| try { |
| Properties properties = new Properties(); |
| File file = new File(PROPERTIES_FILE); |
| stream = new FileInputStream(file); |
| properties.load(stream); |
| mNtpServer = properties.getProperty("NTP_SERVER", null); |
| } catch (IOException e) { |
| Slog.e(TAG, "Could not open GPS configuration file " + PROPERTIES_FILE); |
| } finally { |
| if (stream != null) { |
| try { |
| stream.close(); |
| } catch (Exception e) {} |
| } |
| } |
| } |
| |
| |
| private static final int EVENT_REBOOT_RECOVERY = 0; |
| private static final int EVENT_POLICY_CHANGED = 1; |
| private static final int EVENT_POLL_ALARM = 2; |
| private static final int EVENT_RESET_ALARM = 3; |
| private static final int EVENT_IFACE_UP = 4; |
| private class MyHandler extends Handler { |
| public MyHandler(Looper l) { |
| super(l); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case EVENT_REBOOT_RECOVERY: |
| onRebootRecovery(); |
| break; |
| case EVENT_POLICY_CHANGED: |
| onPolicyChanged(); |
| break; |
| case EVENT_POLL_ALARM: |
| onPollAlarm(); |
| break; |
| case EVENT_RESET_ALARM: |
| onResetAlarm(); |
| break; |
| case EVENT_IFACE_UP: |
| onIfaceUp(); |
| } |
| } |
| |
| private void onRebootRecovery() { |
| if (VDBG) Slog.v(TAG, "onRebootRecovery"); |
| // check for sim change TODO |
| // reregister for notification of policy change |
| |
| mThrottleIndex = THROTTLE_INDEX_UNINITIALIZED; |
| |
| mRecorder = new DataRecorder(mContext, ThrottleService.this); |
| |
| // get policy |
| mHandler.obtainMessage(EVENT_POLICY_CHANGED).sendToTarget(); |
| |
| // if we poll now we won't have network connectivity or even imsi access |
| // queue up a poll to happen in a little while - after ntp and imsi are avail |
| // TODO - make this callback based (ie, listen for notificaitons) |
| mHandler.sendMessageDelayed(mHandler.obtainMessage(EVENT_POLL_ALARM), |
| INITIAL_POLL_DELAY_SEC * 1000); |
| } |
| |
| // check for new policy info (threshold limit/value/etc) |
| private void onPolicyChanged() { |
| boolean testing = SystemProperties.get(TESTING_ENABLED_PROPERTY).equals("true"); |
| |
| int pollingPeriod = mContext.getResources().getInteger( |
| R.integer.config_datause_polling_period_sec); |
| mPolicyPollPeriodSec = Settings.Secure.getInt(mContext.getContentResolver(), |
| Settings.Secure.THROTTLE_POLLING_SEC, pollingPeriod); |
| |
| // TODO - remove testing stuff? |
| long defaultThreshold = mContext.getResources().getInteger( |
| R.integer.config_datause_threshold_bytes); |
| int defaultValue = mContext.getResources().getInteger( |
| R.integer.config_datause_throttle_kbitsps); |
| synchronized (ThrottleService.this) { |
| mPolicyThreshold = Settings.Secure.getLong(mContext.getContentResolver(), |
| Settings.Secure.THROTTLE_THRESHOLD_BYTES, defaultThreshold); |
| mPolicyThrottleValue = Settings.Secure.getInt(mContext.getContentResolver(), |
| Settings.Secure.THROTTLE_VALUE_KBITSPS, defaultValue); |
| if (testing) { |
| mPolicyPollPeriodSec = TESTING_POLLING_PERIOD_SEC; |
| mPolicyThreshold = TESTING_THRESHOLD; |
| } |
| } |
| |
| mPolicyResetDay = Settings.Secure.getInt(mContext.getContentResolver(), |
| Settings.Secure.THROTTLE_RESET_DAY, -1); |
| if (mPolicyResetDay == -1 || |
| ((mPolicyResetDay < 1) || (mPolicyResetDay > 28))) { |
| Random g = new Random(); |
| mPolicyResetDay = 1 + g.nextInt(28); // 1-28 |
| Settings.Secure.putInt(mContext.getContentResolver(), |
| Settings.Secure.THROTTLE_RESET_DAY, mPolicyResetDay); |
| } |
| synchronized (ThrottleService.this) { |
| if (mIface == null) { |
| mPolicyThreshold = 0; |
| } |
| } |
| |
| int defaultNotificationType = mContext.getResources().getInteger( |
| R.integer.config_datause_notification_type); |
| mPolicyNotificationsAllowedMask = Settings.Secure.getInt(mContext.getContentResolver(), |
| Settings.Secure.THROTTLE_NOTIFICATION_TYPE, defaultNotificationType); |
| |
| mMaxNtpCacheAgeSec = Settings.Secure.getInt(mContext.getContentResolver(), |
| Settings.Secure.THROTTLE_MAX_NTP_CACHE_AGE_SEC, MAX_NTP_CACHE_AGE_SEC); |
| |
| if (VDBG || (mPolicyThreshold != 0)) { |
| Slog.d(TAG, "onPolicyChanged testing=" + testing +", period=" + |
| mPolicyPollPeriodSec + ", threshold=" + mPolicyThreshold + ", value=" + |
| mPolicyThrottleValue + ", resetDay=" + mPolicyResetDay + ", noteType=" + |
| mPolicyNotificationsAllowedMask + ", maxNtpCacheAge=" + mMaxNtpCacheAgeSec); |
| } |
| |
| // force updates |
| mThrottleIndex = THROTTLE_INDEX_UNINITIALIZED; |
| |
| onResetAlarm(); |
| |
| onPollAlarm(); |
| |
| Intent broadcast = new Intent(ThrottleManager.POLICY_CHANGED_ACTION); |
| mContext.sendBroadcast(broadcast); |
| } |
| |
| private void onPollAlarm() { |
| long now = SystemClock.elapsedRealtime(); |
| long next = now + mPolicyPollPeriodSec*1000; |
| |
| checkForAuthoritativeTime(); |
| |
| long incRead = 0; |
| long incWrite = 0; |
| try { |
| incRead = mNMService.getInterfaceRxCounter(mIface) - mLastRead; |
| incWrite = mNMService.getInterfaceTxCounter(mIface) - mLastWrite; |
| // handle iface resets - on some device the 3g iface comes and goes and gets |
| // totals reset to 0. Deal with it |
| if ((incRead < 0) || (incWrite < 0)) { |
| incRead += mLastRead; |
| incWrite += mLastWrite; |
| mLastRead = 0; |
| mLastWrite = 0; |
| } |
| } catch (RemoteException e) { |
| Slog.e(TAG, "got remoteException in onPollAlarm:" + e); |
| } |
| // don't count this data if we're roaming. |
| boolean roaming = "true".equals( |
| SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_ISROAMING)); |
| if (!roaming) { |
| mRecorder.addData(incRead, incWrite); |
| } |
| |
| long periodRx = mRecorder.getPeriodRx(0); |
| long periodTx = mRecorder.getPeriodTx(0); |
| long total = periodRx + periodTx; |
| if (VDBG || (mPolicyThreshold != 0)) { |
| Slog.d(TAG, "onPollAlarm - roaming =" + roaming + |
| ", read =" + incRead + ", written =" + incWrite + ", new total =" + total); |
| } |
| mLastRead += incRead; |
| mLastWrite += incWrite; |
| |
| checkThrottleAndPostNotification(total); |
| |
| Intent broadcast = new Intent(ThrottleManager.THROTTLE_POLL_ACTION); |
| broadcast.putExtra(ThrottleManager.EXTRA_CYCLE_READ, periodRx); |
| broadcast.putExtra(ThrottleManager.EXTRA_CYCLE_WRITE, periodTx); |
| broadcast.putExtra(ThrottleManager.EXTRA_CYCLE_START, getPeriodStartTime(mIface)); |
| broadcast.putExtra(ThrottleManager.EXTRA_CYCLE_END, getResetTime(mIface)); |
| mContext.sendStickyBroadcast(broadcast); |
| |
| mAlarmManager.cancel(mPendingPollIntent); |
| mAlarmManager.set(AlarmManager.ELAPSED_REALTIME, next, mPendingPollIntent); |
| } |
| |
| private void onIfaceUp() { |
| // if we were throttled before, be sure and set it again - the iface went down |
| // (and may have disappeared all together) and these settings were lost |
| if (mThrottleIndex == 1) { |
| try { |
| mNMService.setInterfaceThrottle(mIface, -1, -1); |
| mNMService.setInterfaceThrottle(mIface, |
| mPolicyThrottleValue, mPolicyThrottleValue); |
| } catch (Exception e) { |
| Slog.e(TAG, "error setting Throttle: " + e); |
| } |
| } |
| } |
| |
| private void checkThrottleAndPostNotification(long currentTotal) { |
| // is throttling enabled? |
| if (mPolicyThreshold == 0) { |
| clearThrottleAndNotification(); |
| return; |
| } |
| |
| // have we spoken with an ntp server yet? |
| // this is controversial, but we'd rather err towards not throttling |
| if ((mNtpServer != null) && !mNtpActive) { |
| return; |
| } |
| |
| // check if we need to throttle |
| if (currentTotal > mPolicyThreshold) { |
| if (mThrottleIndex != 1) { |
| synchronized (ThrottleService.this) { |
| mThrottleIndex = 1; |
| } |
| if (DBG) Slog.d(TAG, "Threshold " + mPolicyThreshold + " exceeded!"); |
| try { |
| mNMService.setInterfaceThrottle(mIface, |
| mPolicyThrottleValue, mPolicyThrottleValue); |
| } catch (Exception e) { |
| Slog.e(TAG, "error setting Throttle: " + e); |
| } |
| |
| mNotificationManager.cancel(R.drawable.stat_sys_throttled); |
| |
| postNotification(R.string.throttled_notification_title, |
| R.string.throttled_notification_message, |
| R.drawable.stat_sys_throttled, |
| Notification.FLAG_ONGOING_EVENT); |
| |
| Intent broadcast = new Intent(ThrottleManager.THROTTLE_ACTION); |
| broadcast.putExtra(ThrottleManager.EXTRA_THROTTLE_LEVEL, mPolicyThrottleValue); |
| mContext.sendStickyBroadcast(broadcast); |
| |
| } // else already up! |
| } else { |
| clearThrottleAndNotification(); |
| if ((mPolicyNotificationsAllowedMask & NOTIFICATION_WARNING) != 0) { |
| // check if we should warn about throttle |
| // pretend we only have 1/2 the time remaining that we actually do |
| // if our burn rate in the period so far would have us exceed the limit |
| // in that 1/2 window, warn the user. |
| // this gets more generous in the early to middle period and converges back |
| // to the limit as we move toward the period end. |
| |
| // adding another factor - it must be greater than the total cap/4 |
| // else we may get false alarms very early in the period.. in the first |
| // tenth of a percent of the period if we used more than a tenth of a percent |
| // of the cap we'd get a warning and that's not desired. |
| long start = mRecorder.getPeriodStart(); |
| long end = mRecorder.getPeriodEnd(); |
| long periodLength = end - start; |
| long now = System.currentTimeMillis(); |
| long timeUsed = now - start; |
| long warningThreshold = 2*mPolicyThreshold*timeUsed/(timeUsed+periodLength); |
| if ((currentTotal > warningThreshold) && (currentTotal > mPolicyThreshold/4)) { |
| if (mWarningNotificationSent == false) { |
| mWarningNotificationSent = true; |
| mNotificationManager.cancel(R.drawable.stat_sys_throttled); |
| postNotification(R.string.throttle_warning_notification_title, |
| R.string.throttle_warning_notification_message, |
| R.drawable.stat_sys_throttled, |
| 0); |
| } |
| } else { |
| if (mWarningNotificationSent == true) { |
| mNotificationManager.cancel(R.drawable.stat_sys_throttled); |
| mWarningNotificationSent =false; |
| } |
| } |
| } |
| } |
| } |
| |
| private void postNotification(int titleInt, int messageInt, int icon, int flags) { |
| Intent intent = new Intent(); |
| // TODO - fix up intent |
| intent.setClassName("com.android.phone", "com.android.phone.DataUsage"); |
| intent.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY); |
| |
| PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0); |
| |
| Resources r = Resources.getSystem(); |
| CharSequence title = r.getText(titleInt); |
| CharSequence message = r.getText(messageInt); |
| if (mThrottlingNotification == null) { |
| mThrottlingNotification = new Notification(); |
| mThrottlingNotification.when = 0; |
| // TODO - fixup icon |
| mThrottlingNotification.icon = icon; |
| mThrottlingNotification.defaults &= ~Notification.DEFAULT_SOUND; |
| } |
| mThrottlingNotification.flags = flags; |
| mThrottlingNotification.tickerText = title; |
| mThrottlingNotification.setLatestEventInfo(mContext, title, message, pi); |
| |
| mNotificationManager.notify(mThrottlingNotification.icon, mThrottlingNotification); |
| } |
| |
| |
| private synchronized void clearThrottleAndNotification() { |
| if (mThrottleIndex != THROTTLE_INDEX_UNTHROTTLED) { |
| synchronized (ThrottleService.this) { |
| mThrottleIndex = THROTTLE_INDEX_UNTHROTTLED; |
| } |
| try { |
| mNMService.setInterfaceThrottle(mIface, -1, -1); |
| } catch (Exception e) { |
| Slog.e(TAG, "error clearing Throttle: " + e); |
| } |
| Intent broadcast = new Intent(ThrottleManager.THROTTLE_ACTION); |
| broadcast.putExtra(ThrottleManager.EXTRA_THROTTLE_LEVEL, -1); |
| mContext.sendStickyBroadcast(broadcast); |
| mNotificationManager.cancel(R.drawable.stat_sys_throttled); |
| mWarningNotificationSent = false; |
| } |
| } |
| |
| private Calendar calculatePeriodEnd(long now) { |
| Calendar end = GregorianCalendar.getInstance(); |
| end.setTimeInMillis(now); |
| int day = end.get(Calendar.DAY_OF_MONTH); |
| end.set(Calendar.DAY_OF_MONTH, mPolicyResetDay); |
| end.set(Calendar.HOUR_OF_DAY, 0); |
| end.set(Calendar.MINUTE, 0); |
| end.set(Calendar.SECOND, 0); |
| end.set(Calendar.MILLISECOND, 0); |
| if (day >= mPolicyResetDay) { |
| int month = end.get(Calendar.MONTH); |
| if (month == Calendar.DECEMBER) { |
| end.set(Calendar.YEAR, end.get(Calendar.YEAR) + 1); |
| month = Calendar.JANUARY - 1; |
| } |
| end.set(Calendar.MONTH, month + 1); |
| } |
| |
| // TODO - remove! |
| if (SystemProperties.get(TESTING_ENABLED_PROPERTY).equals("true")) { |
| end = GregorianCalendar.getInstance(); |
| end.setTimeInMillis(now); |
| end.add(Calendar.SECOND, TESTING_RESET_PERIOD_SEC); |
| } |
| return end; |
| } |
| private Calendar calculatePeriodStart(Calendar end) { |
| Calendar start = (Calendar)end.clone(); |
| int month = end.get(Calendar.MONTH); |
| if (end.get(Calendar.MONTH) == Calendar.JANUARY) { |
| month = Calendar.DECEMBER + 1; |
| start.set(Calendar.YEAR, start.get(Calendar.YEAR) - 1); |
| } |
| start.set(Calendar.MONTH, month - 1); |
| |
| // TODO - remove!! |
| if (SystemProperties.get(TESTING_ENABLED_PROPERTY).equals("true")) { |
| start = (Calendar)end.clone(); |
| start.add(Calendar.SECOND, -TESTING_RESET_PERIOD_SEC); |
| } |
| return start; |
| } |
| |
| private void onResetAlarm() { |
| if (VDBG || (mPolicyThreshold != 0)) { |
| Slog.d(TAG, "onResetAlarm - last period had " + mRecorder.getPeriodRx(0) + |
| " bytes read and " + mRecorder.getPeriodTx(0) + " written"); |
| } |
| |
| long now = getBestTime(); |
| |
| if (mNtpActive || (mNtpServer == null)) { |
| Calendar end = calculatePeriodEnd(now); |
| Calendar start = calculatePeriodStart(end); |
| |
| if (mRecorder.setNextPeriod(start, end)) { |
| onPollAlarm(); |
| } |
| |
| mAlarmManager.cancel(mPendingResetIntent); |
| long offset = end.getTimeInMillis() - now; |
| // use Elapsed realtime so clock changes don't fool us. |
| mAlarmManager.set(AlarmManager.ELAPSED_REALTIME, |
| SystemClock.elapsedRealtime() + offset, |
| mPendingResetIntent); |
| } else { |
| if (VDBG) Slog.d(TAG, "no authoritative time - not resetting period"); |
| } |
| } |
| } |
| |
| private void checkForAuthoritativeTime() { |
| if (mNtpActive || (mNtpServer == null)) return; |
| |
| // will try to get the ntp time and switch to it if found. |
| // will also cache the time so we don't fetch it repeatedly. |
| getBestTime(); |
| } |
| |
| private static final int MAX_NTP_CACHE_AGE_SEC = 60 * 60 * 24; // 1 day |
| private static final int MAX_NTP_FETCH_WAIT = 10 * 1000; |
| private int mMaxNtpCacheAgeSec = MAX_NTP_CACHE_AGE_SEC; |
| private long cachedNtp; |
| private long cachedNtpTimestamp; |
| |
| private long getBestTime() { |
| if (mNtpServer != null) { |
| if (mNtpActive) { |
| long ntpAge = SystemClock.elapsedRealtime() - cachedNtpTimestamp; |
| if (ntpAge < mMaxNtpCacheAgeSec * 1000) { |
| if (VDBG) Slog.v(TAG, "using cached time"); |
| return cachedNtp + ntpAge; |
| } |
| } |
| SntpClient client = new SntpClient(); |
| if (client.requestTime(mNtpServer, MAX_NTP_FETCH_WAIT)) { |
| cachedNtp = client.getNtpTime(); |
| cachedNtpTimestamp = SystemClock.elapsedRealtime(); |
| if (!mNtpActive) { |
| mNtpActive = true; |
| if (VDBG) Slog.d(TAG, "found Authoritative time - reseting alarm"); |
| mHandler.obtainMessage(EVENT_RESET_ALARM).sendToTarget(); |
| } |
| if (VDBG) Slog.v(TAG, "using Authoritative time: " + cachedNtp); |
| return cachedNtp; |
| } |
| } |
| long time = System.currentTimeMillis(); |
| if (VDBG) Slog.v(TAG, "using User time: " + time); |
| mNtpActive = false; |
| return time; |
| } |
| |
| // records bytecount data for a given time and accumulates it into larger time windows |
| // for logging and other purposes |
| // |
| // since time can be changed (user or network action) we will have to track the time of the |
| // last recording and deal with it. |
| private static class DataRecorder { |
| long[] mPeriodRxData; |
| long[] mPeriodTxData; |
| int mCurrentPeriod; |
| int mPeriodCount; |
| |
| Calendar mPeriodStart; |
| Calendar mPeriodEnd; |
| |
| ThrottleService mParent; |
| Context mContext; |
| String mImsi = null; |
| |
| TelephonyManager mTelephonyManager; |
| |
| DataRecorder(Context context, ThrottleService parent) { |
| mContext = context; |
| mParent = parent; |
| |
| mTelephonyManager = (TelephonyManager)mContext.getSystemService( |
| Context.TELEPHONY_SERVICE); |
| |
| synchronized (mParent) { |
| mPeriodCount = 6; |
| mPeriodRxData = new long[mPeriodCount]; |
| mPeriodTxData = new long[mPeriodCount]; |
| |
| mPeriodStart = Calendar.getInstance(); |
| mPeriodEnd = Calendar.getInstance(); |
| |
| retrieve(); |
| } |
| } |
| |
| boolean setNextPeriod(Calendar start, Calendar end) { |
| // TODO - how would we deal with a dual-IMSI device? |
| checkForSubscriberId(); |
| boolean startNewPeriod = true; |
| |
| if (start.equals(mPeriodStart) && end.equals(mPeriodEnd)) { |
| // same endpoints - keep collecting |
| if (VDBG) { |
| Slog.d(TAG, "same period (" + start.getTimeInMillis() + "," + |
| end.getTimeInMillis() +") - ammending data"); |
| } |
| startNewPeriod = false; |
| } else { |
| if (VDBG) { |
| if(start.equals(mPeriodEnd) || start.after(mPeriodEnd)) { |
| Slog.d(TAG, "next period (" + start.getTimeInMillis() + "," + |
| end.getTimeInMillis() + ") - old end was " + |
| mPeriodEnd.getTimeInMillis() + ", following"); |
| } else { |
| Slog.d(TAG, "new period (" + start.getTimeInMillis() + "," + |
| end.getTimeInMillis() + ") replacing old (" + |
| mPeriodStart.getTimeInMillis() + "," + |
| mPeriodEnd.getTimeInMillis() + ")"); |
| } |
| } |
| synchronized (mParent) { |
| ++mCurrentPeriod; |
| if (mCurrentPeriod >= mPeriodCount) mCurrentPeriod = 0; |
| mPeriodRxData[mCurrentPeriod] = 0; |
| mPeriodTxData[mCurrentPeriod] = 0; |
| } |
| } |
| setPeriodStart(start); |
| setPeriodEnd(end); |
| record(); |
| return startNewPeriod; |
| } |
| |
| public long getPeriodEnd() { |
| synchronized (mParent) { |
| return mPeriodEnd.getTimeInMillis(); |
| } |
| } |
| |
| private void setPeriodEnd(Calendar end) { |
| synchronized (mParent) { |
| mPeriodEnd = end; |
| } |
| } |
| |
| public long getPeriodStart() { |
| synchronized (mParent) { |
| return mPeriodStart.getTimeInMillis(); |
| } |
| } |
| |
| private void setPeriodStart(Calendar start) { |
| synchronized (mParent) { |
| mPeriodStart = start; |
| } |
| } |
| |
| public int getPeriodCount() { |
| synchronized (mParent) { |
| return mPeriodCount; |
| } |
| } |
| |
| private void zeroData(int field) { |
| synchronized (mParent) { |
| for(int period = 0; period<mPeriodCount; period++) { |
| mPeriodRxData[period] = 0; |
| mPeriodTxData[period] = 0; |
| } |
| mCurrentPeriod = 0; |
| } |
| |
| } |
| |
| // if time moves backward accumulate all read/write that's lost into the now |
| // otherwise time moved forward. |
| void addData(long bytesRead, long bytesWritten) { |
| checkForSubscriberId(); |
| |
| synchronized (mParent) { |
| mPeriodRxData[mCurrentPeriod] += bytesRead; |
| mPeriodTxData[mCurrentPeriod] += bytesWritten; |
| } |
| record(); |
| } |
| |
| private File getDataFile() { |
| File dataDir = Environment.getDataDirectory(); |
| File throttleDir = new File(dataDir, "system/throttle"); |
| throttleDir.mkdirs(); |
| String mImsi = mTelephonyManager.getSubscriberId(); |
| File dataFile; |
| if (mImsi == null) { |
| dataFile = useMRUFile(throttleDir); |
| if (VDBG) Slog.v(TAG, "imsi not available yet, using " + dataFile); |
| } else { |
| String imsiHash = Integer.toString(mImsi.hashCode()); |
| dataFile = new File(throttleDir, imsiHash); |
| } |
| // touch the file so it's not LRU |
| dataFile.setLastModified(System.currentTimeMillis()); |
| checkAndDeleteLRUDataFile(throttleDir); |
| return dataFile; |
| } |
| |
| // TODO - get broadcast (TelephonyIntents.ACTION_SIM_STATE_CHANGED) instead of polling |
| private void checkForSubscriberId() { |
| if (mImsi != null) return; |
| |
| mImsi = mTelephonyManager.getSubscriberId(); |
| if (mImsi == null) return; |
| |
| if (VDBG) Slog.d(TAG, "finally have imsi - retreiving data"); |
| retrieve(); |
| } |
| |
| private final static int MAX_SIMS_SUPPORTED = 3; |
| |
| private void checkAndDeleteLRUDataFile(File dir) { |
| File[] files = dir.listFiles(); |
| |
| if (files.length <= MAX_SIMS_SUPPORTED) return; |
| if (DBG) Slog.d(TAG, "Too many data files"); |
| do { |
| File oldest = null; |
| for (File f : files) { |
| if ((oldest == null) || (oldest.lastModified() > f.lastModified())) { |
| oldest = f; |
| } |
| } |
| if (oldest == null) return; |
| if (DBG) Slog.d(TAG, " deleting " + oldest); |
| oldest.delete(); |
| files = dir.listFiles(); |
| } while (files.length > MAX_SIMS_SUPPORTED); |
| } |
| |
| private File useMRUFile(File dir) { |
| File newest = null; |
| File[] files = dir.listFiles(); |
| |
| for (File f : files) { |
| if ((newest == null) || (newest.lastModified() < f.lastModified())) { |
| newest = f; |
| } |
| } |
| if (newest == null) { |
| newest = new File(dir, "temp"); |
| } |
| return newest; |
| } |
| |
| |
| private static final int DATA_FILE_VERSION = 1; |
| |
| private void record() { |
| // 1 int version |
| // 1 int mPeriodCount |
| // 13*6 long[PERIOD_COUNT] mPeriodRxData |
| // 13*6 long[PERIOD_COUNT] mPeriodTxData |
| // 1 int mCurrentPeriod |
| // 13 long periodStartMS |
| // 13 long periodEndMS |
| // 200 chars max |
| StringBuilder builder = new StringBuilder(); |
| builder.append(DATA_FILE_VERSION); |
| builder.append(":"); |
| builder.append(mPeriodCount); |
| builder.append(":"); |
| for(int i = 0; i < mPeriodCount; i++) { |
| builder.append(mPeriodRxData[i]); |
| builder.append(":"); |
| } |
| for(int i = 0; i < mPeriodCount; i++) { |
| builder.append(mPeriodTxData[i]); |
| builder.append(":"); |
| } |
| builder.append(mCurrentPeriod); |
| builder.append(":"); |
| builder.append(mPeriodStart.getTimeInMillis()); |
| builder.append(":"); |
| builder.append(mPeriodEnd.getTimeInMillis()); |
| |
| BufferedWriter out = null; |
| try { |
| out = new BufferedWriter(new FileWriter(getDataFile()), 256); |
| out.write(builder.toString()); |
| } catch (IOException e) { |
| Slog.e(TAG, "Error writing data file"); |
| return; |
| } finally { |
| if (out != null) { |
| try { |
| out.close(); |
| } catch (Exception e) {} |
| } |
| } |
| } |
| |
| private void retrieve() { |
| // clean out any old data first. If we fail to read we don't want old stuff |
| zeroData(0); |
| |
| File f = getDataFile(); |
| byte[] buffer; |
| FileInputStream s = null; |
| try { |
| buffer = new byte[(int)f.length()]; |
| s = new FileInputStream(f); |
| s.read(buffer); |
| } catch (IOException e) { |
| Slog.e(TAG, "Error reading data file"); |
| return; |
| } finally { |
| if (s != null) { |
| try { |
| s.close(); |
| } catch (Exception e) {} |
| } |
| } |
| String data = new String(buffer); |
| if (data == null || data.length() == 0) { |
| if (DBG) Slog.d(TAG, "data file empty"); |
| return; |
| } |
| synchronized (mParent) { |
| String[] parsed = data.split(":"); |
| int parsedUsed = 0; |
| if (parsed.length < 6) { |
| Slog.e(TAG, "reading data file with insufficient length - ignoring"); |
| return; |
| } |
| |
| if (Integer.parseInt(parsed[parsedUsed++]) != DATA_FILE_VERSION) { |
| Slog.e(TAG, "reading data file with bad version - ignoring"); |
| return; |
| } |
| |
| mPeriodCount = Integer.parseInt(parsed[parsedUsed++]); |
| if (parsed.length != 5 + (2 * mPeriodCount)) { |
| Slog.e(TAG, "reading data file with bad length (" + parsed.length + |
| " != " + (5+(2*mPeriodCount)) + ") - ignoring"); |
| return; |
| } |
| |
| mPeriodRxData = new long[mPeriodCount]; |
| for(int i = 0; i < mPeriodCount; i++) { |
| mPeriodRxData[i] = Long.parseLong(parsed[parsedUsed++]); |
| } |
| mPeriodTxData = new long[mPeriodCount]; |
| for(int i = 0; i < mPeriodCount; i++) { |
| mPeriodTxData[i] = Long.parseLong(parsed[parsedUsed++]); |
| } |
| mCurrentPeriod = Integer.parseInt(parsed[parsedUsed++]); |
| mPeriodStart = new GregorianCalendar(); |
| mPeriodStart.setTimeInMillis(Long.parseLong(parsed[parsedUsed++])); |
| mPeriodEnd = new GregorianCalendar(); |
| mPeriodEnd.setTimeInMillis(Long.parseLong(parsed[parsedUsed++])); |
| } |
| } |
| |
| long getPeriodRx(int which) { |
| synchronized (mParent) { |
| if (which > mPeriodCount) return 0; |
| which = mCurrentPeriod - which; |
| if (which < 0) which += mPeriodCount; |
| return mPeriodRxData[which]; |
| } |
| } |
| long getPeriodTx(int which) { |
| synchronized (mParent) { |
| if (which > mPeriodCount) return 0; |
| which = mCurrentPeriod - which; |
| if (which < 0) which += mPeriodCount; |
| return mPeriodTxData[which]; |
| } |
| } |
| } |
| |
| @Override |
| protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { |
| if (mContext.checkCallingOrSelfPermission( |
| android.Manifest.permission.DUMP) |
| != PackageManager.PERMISSION_GRANTED) { |
| pw.println("Permission Denial: can't dump ThrottleService " + |
| "from from pid=" + Binder.getCallingPid() + ", uid=" + |
| Binder.getCallingUid()); |
| return; |
| } |
| pw.println(); |
| |
| pw.println("The threshold is " + mPolicyThreshold + |
| ", after which you experince throttling to " + |
| mPolicyThrottleValue + "kbps"); |
| pw.println("Current period is " + |
| (mRecorder.getPeriodEnd() - mRecorder.getPeriodStart())/1000 + " seconds long " + |
| "and ends in " + (getResetTime(mIface) - System.currentTimeMillis()) / 1000 + |
| " seconds."); |
| pw.println("Polling every " + mPolicyPollPeriodSec + " seconds"); |
| pw.println("Current Throttle Index is " + mThrottleIndex); |
| pw.println("Max NTP Cache Age is " + mMaxNtpCacheAgeSec); |
| |
| for (int i = 0; i < mRecorder.getPeriodCount(); i++) { |
| pw.println(" Period[" + i + "] - read:" + mRecorder.getPeriodRx(i) + ", written:" + |
| mRecorder.getPeriodTx(i)); |
| } |
| } |
| } |
