コード例 #1
0
 @SmallTest
 public void testStressMemoryPropertyConsistency() throws Exception {
   for (int i = 0; i < 100; ++i) {
     SystemProperties.set(KEY, Long.toString(i));
     long ret = SystemProperties.getLong(KEY, -1);
     assertEquals(i, ret);
   }
 }
コード例 #2
0
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setContentView(R.layout.bt_debug_feature);

    TextView tv = (TextView) findViewById(R.id.BTDebugFeaturetxv);
    tv.setText(Html.fromHtml(getString(R.string.BtDebugFeature)));

    mChecked = (CheckBox) findViewById(R.id.BTDebugFeatureCb);
    mChecked.setOnClickListener(this);
    if (0xFFFFFFFFL == SystemProperties.getLong(KEY_DEBUG_FEATURE, 0)) {
      mChecked.setChecked(true);
    } else {
      mChecked.setChecked(false);
    }
  }
 private void updateEnableTracesOptions() {
   long flags = SystemProperties.getLong(Trace.PROPERTY_TRACE_TAG_ENABLEFLAGS, 0);
   String[] values = mEnableTracesPref.getEntryValues();
   int numSet = 0;
   for (int i = Trace.TRACE_FLAGS_START_BIT; i < values.length; i++) {
     boolean set = (flags & (1 << i)) != 0;
     mEnableTracesPref.setValue(i - Trace.TRACE_FLAGS_START_BIT, set);
     if (set) {
       numSet++;
     }
   }
   if (numSet == 0) {
     mEnableTracesPref.setSummary(R.string.enable_traces_summary_none);
   } else if (numSet == values.length) {
     mHaveDebugSettings = true;
     mEnableTracesPref.setSummary(R.string.enable_traces_summary_all);
   } else {
     mHaveDebugSettings = true;
     mEnableTracesPref.setSummary(getString(R.string.enable_traces_summary_num, numSet));
   }
 }
  private void logBootEvents(Context ctx) throws IOException {
    final DropBoxManager db = (DropBoxManager) ctx.getSystemService(Context.DROPBOX_SERVICE);
    final SharedPreferences prefs = ctx.getSharedPreferences("log_files", Context.MODE_PRIVATE);
    final String headers =
        new StringBuilder(512)
            .append("Build: ")
            .append(Build.FINGERPRINT)
            .append("\n")
            .append("Hardware: ")
            .append(Build.BOARD)
            .append("\n")
            .append("Bootloader: ")
            .append(Build.BOOTLOADER)
            .append("\n")
            .append("Radio: ")
            .append(Build.RADIO)
            .append("\n")
            .append("Kernel: ")
            .append(FileUtils.readTextFile(new File("/proc/version"), 1024, "...\n"))
            .append("\n")
            .toString();

    String recovery = RecoverySystem.handleAftermath();
    if (recovery != null && db != null) {
      db.addText("SYSTEM_RECOVERY_LOG", headers + recovery);
    }

    if (SystemProperties.getLong("ro.runtime.firstboot", 0) == 0) {
      String now = Long.toString(System.currentTimeMillis());
      SystemProperties.set("ro.runtime.firstboot", now);
      if (db != null) db.addText("SYSTEM_BOOT", headers);

      // Negative sizes mean to take the *tail* of the file (see FileUtils.readTextFile())
      addFileToDropBox(db, prefs, headers, "/proc/last_kmsg", -LOG_SIZE, "SYSTEM_LAST_KMSG");
      addFileToDropBox(db, prefs, headers, "/cache/recovery/log", -LOG_SIZE, "SYSTEM_RECOVERY_LOG");
      addFileToDropBox(
          db, prefs, headers, "/data/dontpanic/apanic_console", -LOG_SIZE, "APANIC_CONSOLE");
      addFileToDropBox(
          db, prefs, headers, "/data/dontpanic/apanic_threads", -LOG_SIZE, "APANIC_THREADS");
    } else {
      if (db != null) db.addText("SYSTEM_RESTART", headers);
    }

    // Scan existing tombstones (in case any new ones appeared)
    File[] tombstoneFiles = TOMBSTONE_DIR.listFiles();
    for (int i = 0; tombstoneFiles != null && i < tombstoneFiles.length; i++) {
      addFileToDropBox(
          db, prefs, headers, tombstoneFiles[i].getPath(), LOG_SIZE, "SYSTEM_TOMBSTONE");
    }

    // Start watching for new tombstone files; will record them as they occur.
    // This gets registered with the singleton file observer thread.
    sTombstoneObserver =
        new FileObserver(TOMBSTONE_DIR.getPath(), FileObserver.CLOSE_WRITE) {
          @Override
          public void onEvent(int event, String path) {
            try {
              String filename = new File(TOMBSTONE_DIR, path).getPath();
              addFileToDropBox(db, prefs, headers, filename, LOG_SIZE, "SYSTEM_TOMBSTONE");
            } catch (IOException e) {
              Slog.e(TAG, "Can't log tombstone", e);
            }
          }
        };

    sTombstoneObserver.startWatching();
  }
コード例 #5
0
/**
 * Sensor manager implementation that communicates with the built-in system sensors.
 *
 * @hide
 */
public class SystemSensorManager extends SensorManager {
  private static final int SENSOR_DISABLE = -1;
  private static final long SENSOR_LOOPMINMS =
      SystemProperties.getLong(
          "sensor.loop.minms",
          0); // minimal duration of a sensor loop => sleep to prevent notification storm if faster
              // than that.
  private static final float MAGNITUDE_THRESHOLD =
      ((float) SystemProperties.getLong("sensor.magnitude.threshold", 0)) / 1000.0f;

  private static boolean sSensorModuleInitialized = false;
  private static ArrayList<Sensor> sFullSensorsList = new ArrayList<Sensor>();
  /* The thread and the sensor list are global to the process
   * but the actual thread is spawned on demand */
  private static SensorThread sSensorThread;
  private static int sQueue;

  // Used within this module from outside SensorManager, don't make private
  static SparseArray<Sensor> sHandleToSensor = new SparseArray<Sensor>();
  static final ArrayList<ListenerDelegate> sListeners = new ArrayList<ListenerDelegate>();

  // Common pool of sensor events.
  static SensorEventPool sPool;

  // Looper associated with the context in which this instance was created.
  final Looper mMainLooper;

  /*-----------------------------------------------------------------------*/

  private static class SensorThread {

    Thread mThread;
    boolean mSensorsReady;

    SensorThread() {}

    @Override
    protected void finalize() {}

    // must be called with sListeners lock
    boolean startLocked() {
      try {
        if (mThread == null) {
          mSensorsReady = false;
          SensorThreadRunnable runnable = new SensorThreadRunnable();
          Thread thread = new Thread(runnable, SensorThread.class.getName());
          thread.start();
          synchronized (runnable) {
            while (mSensorsReady == false) {
              runnable.wait();
            }
          }
          mThread = thread;
        }
      } catch (InterruptedException e) {
      }
      return mThread == null ? false : true;
    }

    private class SensorThreadRunnable implements Runnable {
      SensorThreadRunnable() {}

      private boolean open() {
        // NOTE: this cannot synchronize on sListeners, since
        // it's held in the main thread at least until we
        // return from here.
        sQueue = sensors_create_queue();
        return true;
      }

      public void run() {
        // Log.d(TAG, "entering main sensor thread");
        final float[] values = new float[3];
        final int[] status = new int[1];
        final long timestamp[] = new long[1];
        Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_DISPLAY);

        if (!open()) {
          return;
        }

        synchronized (this) {
          // we've open the driver, we're ready to open the sensors
          mSensorsReady = true;
          this.notify();
        }

        while (true) {
          // wait for an event
          final int sensor = sensors_data_poll(sQueue, values, status, timestamp);
          long lastLoopMS = System.currentTimeMillis();
          long timeToSleep = SENSOR_LOOPMINMS;

          int accuracy = status[0];
          synchronized (sListeners) {
            if (sensor == -1 || sListeners.isEmpty()) {
              // we lost the connection to the event stream. this happens
              // when the last listener is removed or if there is an error
              if (sensor == -1 && !sListeners.isEmpty()) {
                // log a warning in case of abnormal termination
                Log.e(TAG, "_sensors_data_poll() failed, we bail out: sensors=" + sensor);
              }
              // we have no more listeners or polling failed, terminate the thread
              sensors_destroy_queue(sQueue);
              sQueue = 0;
              mThread = null;
              break;
            }
            final Sensor sensorObject = sHandleToSensor.get(sensor);

            if (sensorObject != null) {
              final float mag =
                  FloatMath.sqrt(
                      values[0] * values[0] + values[1] * values[1] + values[2] * values[2]);
              if (Math.abs(mag - SensorManager.STANDARD_GRAVITY) > MAGNITUDE_THRESHOLD) {
                // report the sensor event to all listeners that
                // care about it.
                final int size = sListeners.size();
                for (int i = 0; i < size; i++) {
                  ListenerDelegate listener = sListeners.get(i);
                  if (listener.hasSensor(sensorObject)) {
                    // this is asynchronous (okay to call
                    // with sListeners lock held).
                    listener.onSensorChangedLocked(sensorObject, values, timestamp, accuracy);
                  }
                }
              }
            }
          }

          timeToSleep = SENSOR_LOOPMINMS - (System.currentTimeMillis() - lastLoopMS);
          lastLoopMS = System.currentTimeMillis();
          try {
            if (timeToSleep > 0) Thread.sleep(timeToSleep);
          } catch (InterruptedException e) {;
          }
        }
        // Log.d(TAG, "exiting main sensor thread");
      }
    }
  }

  /*-----------------------------------------------------------------------*/

  private class ListenerDelegate {
    private final SensorEventListener mSensorEventListener;
    private final ArrayList<Sensor> mSensorList = new ArrayList<Sensor>();
    private final Handler mHandler;
    public SparseBooleanArray mSensors = new SparseBooleanArray();
    public SparseBooleanArray mFirstEvent = new SparseBooleanArray();
    public SparseIntArray mSensorAccuracies = new SparseIntArray();

    ListenerDelegate(SensorEventListener listener, Sensor sensor, Handler handler) {
      mSensorEventListener = listener;
      Looper looper = (handler != null) ? handler.getLooper() : mMainLooper;
      // currently we create one Handler instance per listener, but we could
      // have one per looper (we'd need to pass the ListenerDelegate
      // instance to handleMessage and keep track of them separately).
      mHandler =
          new Handler(looper) {
            @Override
            public void handleMessage(Message msg) {
              final SensorEvent t = (SensorEvent) msg.obj;
              final int handle = t.sensor.getHandle();

              switch (t.sensor.getType()) {
                  // Only report accuracy for sensors that support it.
                case Sensor.TYPE_MAGNETIC_FIELD:
                case Sensor.TYPE_ORIENTATION:
                  // call onAccuracyChanged() only if the value changes
                  final int accuracy = mSensorAccuracies.get(handle);
                  if ((t.accuracy >= 0) && (accuracy != t.accuracy)) {
                    mSensorAccuracies.put(handle, t.accuracy);
                    mSensorEventListener.onAccuracyChanged(t.sensor, t.accuracy);
                  }
                  break;
                default:
                  // For other sensors, just report the accuracy once
                  if (mFirstEvent.get(handle) == false) {
                    mFirstEvent.put(handle, true);
                    mSensorEventListener.onAccuracyChanged(t.sensor, SENSOR_STATUS_ACCURACY_HIGH);
                  }
                  break;
              }

              mSensorEventListener.onSensorChanged(t);
              sPool.returnToPool(t);
            }
          };
      addSensor(sensor);
    }

    Object getListener() {
      return mSensorEventListener;
    }

    void addSensor(Sensor sensor) {
      mSensors.put(sensor.getHandle(), true);
      mSensorList.add(sensor);
    }

    int removeSensor(Sensor sensor) {
      mSensors.delete(sensor.getHandle());
      mSensorList.remove(sensor);
      return mSensors.size();
    }

    boolean hasSensor(Sensor sensor) {
      return mSensors.get(sensor.getHandle());
    }

    List<Sensor> getSensors() {
      return mSensorList;
    }

    void onSensorChangedLocked(Sensor sensor, float[] values, long[] timestamp, int accuracy) {
      SensorEvent t = sPool.getFromPool();
      final float[] v = t.values;
      v[0] = values[0];
      v[1] = values[1];
      v[2] = values[2];
      t.timestamp = timestamp[0];
      t.accuracy = accuracy;
      t.sensor = sensor;
      Message msg = Message.obtain();
      msg.what = 0;
      msg.obj = t;
      msg.setAsynchronous(true);
      mHandler.sendMessage(msg);
    }
  }

  /** {@hide} */
  public SystemSensorManager(Looper mainLooper) {
    mMainLooper = mainLooper;

    synchronized (sListeners) {
      if (!sSensorModuleInitialized) {
        sSensorModuleInitialized = true;

        nativeClassInit();

        // initialize the sensor list
        sensors_module_init();
        final ArrayList<Sensor> fullList = sFullSensorsList;
        int i = 0;
        do {
          Sensor sensor = new Sensor();
          i = sensors_module_get_next_sensor(sensor, i);

          if (i >= 0) {
            // Log.d(TAG, "found sensor: " + sensor.getName() +
            //        ", handle=" + sensor.getHandle());
            fullList.add(sensor);
            sHandleToSensor.append(sensor.getHandle(), sensor);
          }
        } while (i > 0);

        sPool = new SensorEventPool(sFullSensorsList.size() * 2);
        sSensorThread = new SensorThread();
      }
    }
  }

  /** @hide */
  @Override
  protected List<Sensor> getFullSensorList() {
    return sFullSensorsList;
  }

  private boolean enableSensorLocked(Sensor sensor, int delay) {
    boolean result = false;
    for (ListenerDelegate i : sListeners) {
      if (i.hasSensor(sensor)) {
        String name = sensor.getName();
        int handle = sensor.getHandle();
        result = sensors_enable_sensor(sQueue, name, handle, delay);
        break;
      }
    }
    return result;
  }

  private boolean disableSensorLocked(Sensor sensor) {
    for (ListenerDelegate i : sListeners) {
      if (i.hasSensor(sensor)) {
        // not an error, it's just that this sensor is still in use
        return true;
      }
    }
    String name = sensor.getName();
    int handle = sensor.getHandle();
    return sensors_enable_sensor(sQueue, name, handle, SENSOR_DISABLE);
  }

  /** @hide */
  @Override
  protected boolean registerListenerImpl(
      SensorEventListener listener, Sensor sensor, int delay, Handler handler) {
    boolean result = true;
    synchronized (sListeners) {
      // look for this listener in our list
      ListenerDelegate l = null;
      for (ListenerDelegate i : sListeners) {
        if (i.getListener() == listener) {
          l = i;
          break;
        }
      }

      // if we don't find it, add it to the list
      if (l == null) {
        l = new ListenerDelegate(listener, sensor, handler);
        sListeners.add(l);
        // if the list is not empty, start our main thread
        if (!sListeners.isEmpty()) {
          if (sSensorThread.startLocked()) {
            if (!enableSensorLocked(sensor, delay)) {
              // oops. there was an error
              sListeners.remove(l);
              result = false;
            }
          } else {
            // there was an error, remove the listener
            sListeners.remove(l);
            result = false;
          }
        } else {
          // weird, we couldn't add the listener
          result = false;
        }
      } else if (!l.hasSensor(sensor)) {
        l.addSensor(sensor);
        if (!enableSensorLocked(sensor, delay)) {
          // oops. there was an error
          l.removeSensor(sensor);
          result = false;
        }
      }
    }

    return result;
  }

  /** @hide */
  @Override
  protected void unregisterListenerImpl(SensorEventListener listener, Sensor sensor) {
    synchronized (sListeners) {
      final int size = sListeners.size();
      for (int i = 0; i < size; i++) {
        ListenerDelegate l = sListeners.get(i);
        if (l.getListener() == listener) {
          if (sensor == null) {
            sListeners.remove(i);
            // disable all sensors for this listener
            for (Sensor s : l.getSensors()) {
              disableSensorLocked(s);
            }
          } else if (l.removeSensor(sensor) == 0) {
            // if we have no more sensors enabled on this listener,
            // take it off the list.
            sListeners.remove(i);
            disableSensorLocked(sensor);
          }
          break;
        }
      }
    }
  }

  private static native void nativeClassInit();

  private static native int sensors_module_init();

  private static native int sensors_module_get_next_sensor(Sensor sensor, int next);

  // Used within this module from outside SensorManager, don't make private
  static native int sensors_create_queue();

  static native void sensors_destroy_queue(int queue);

  static native boolean sensors_enable_sensor(int queue, String name, int sensor, int enable);

  static native int sensors_data_poll(int queue, float[] values, int[] status, long[] timestamp);
}
コード例 #6
0
  private void logBootEvents(Context ctx) throws IOException {
    final DropBoxManager db = (DropBoxManager) ctx.getSystemService(Context.DROPBOX_SERVICE);
    final SharedPreferences prefs = ctx.getSharedPreferences("log_files", Context.MODE_PRIVATE);
    final String headers =
        new StringBuilder(512)
            .append("Build: ")
            .append(Build.FINGERPRINT)
            .append("\n")
            .append("Hardware: ")
            .append(Build.BOARD)
            .append("\n")
            .append("Revision: ")
            .append(SystemProperties.get("ro.revision", ""))
            .append("\n")
            .append("Bootloader: ")
            .append(Build.BOOTLOADER)
            .append("\n")
            .append("Radio: ")
            .append(Build.RADIO)
            .append("\n")
            .append("Kernel: ")
            .append(FileUtils.readTextFile(new File("/proc/version"), 1024, "...\n"))
            .append("\n")
            .toString();
    final String bootReason = SystemProperties.get("ro.boot.bootreason", null);

    String recovery = RecoverySystem.handleAftermath();
    if (recovery != null && db != null) {
      db.addText("SYSTEM_RECOVERY_LOG", headers + recovery);
    }

    String lastKmsgFooter = "";
    if (bootReason != null) {
      lastKmsgFooter =
          new StringBuilder(512)
              .append("\n")
              .append("Boot info:\n")
              .append("Last boot reason: ")
              .append(bootReason)
              .append("\n")
              .toString();
    }

    if (SystemProperties.getLong("ro.runtime.firstboot", 0) == 0) {
      if ("encrypted".equals(SystemProperties.get("ro.crypto.state"))
          && "trigger_restart_min_framework".equals(SystemProperties.get("vold.decrypt"))) {
        // Encrypted, first boot to get PIN/pattern/password so data is tmpfs
        // Don't set ro.runtime.firstboot so that we will do this again
        // when data is properly mounted
      } else {
        String now = Long.toString(System.currentTimeMillis());
        SystemProperties.set("ro.runtime.firstboot", now);
      }
      if (db != null) db.addText("SYSTEM_BOOT", headers);

      // Negative sizes mean to take the *tail* of the file (see FileUtils.readTextFile())
      addFileWithFootersToDropBox(
          db, prefs, headers, lastKmsgFooter, "/proc/last_kmsg", -LOG_SIZE, "SYSTEM_LAST_KMSG");
      addFileWithFootersToDropBox(
          db,
          prefs,
          headers,
          lastKmsgFooter,
          "/sys/fs/pstore/console-ramoops",
          -LOG_SIZE,
          "SYSTEM_LAST_KMSG");
      addFileToDropBox(db, prefs, headers, "/cache/recovery/log", -LOG_SIZE, "SYSTEM_RECOVERY_LOG");
      addFileToDropBox(
          db, prefs, headers, "/cache/recovery/last_kmsg", -LOG_SIZE, "SYSTEM_RECOVERY_KMSG");
      addFileToDropBox(
          db, prefs, headers, "/data/dontpanic/apanic_console", -LOG_SIZE, "APANIC_CONSOLE");
      addFileToDropBox(
          db, prefs, headers, "/data/dontpanic/apanic_threads", -LOG_SIZE, "APANIC_THREADS");
      addAuditErrorsToDropBox(db, prefs, headers, -LOG_SIZE, "SYSTEM_AUDIT");
      addFsckErrorsToDropBox(db, prefs, headers, -LOG_SIZE, "SYSTEM_FSCK");
    } else {
      if (db != null) db.addText("SYSTEM_RESTART", headers);
    }

    // Scan existing tombstones (in case any new ones appeared)
    File[] tombstoneFiles = TOMBSTONE_DIR.listFiles();
    for (int i = 0; tombstoneFiles != null && i < tombstoneFiles.length; i++) {
      if (tombstoneFiles[i].isFile()) {
        addFileToDropBox(
            db, prefs, headers, tombstoneFiles[i].getPath(), LOG_SIZE, "SYSTEM_TOMBSTONE");
      }
    }

    // Start watching for new tombstone files; will record them as they occur.
    // This gets registered with the singleton file observer thread.
    sTombstoneObserver =
        new FileObserver(TOMBSTONE_DIR.getPath(), FileObserver.CLOSE_WRITE) {
          @Override
          public void onEvent(int event, String path) {
            try {
              File file = new File(TOMBSTONE_DIR, path);
              if (file.isFile()) {
                addFileToDropBox(db, prefs, headers, file.getPath(), LOG_SIZE, "SYSTEM_TOMBSTONE");
              }
            } catch (IOException e) {
              Slog.e(TAG, "Can't log tombstone", e);
            }
          }
        };

    sTombstoneObserver.startWatching();
  }