Example usage for android.hardware Sensor getPower

List of usage examples for android.hardware Sensor getPower

Introduction

In this page you can find the example usage for android.hardware Sensor getPower.

Prototype

public float getPower() 

Source Link

Usage

From source file:altermarkive.uploader.Report.java

@SuppressWarnings("unused")
public static String probe(Context context) throws JSONException {
    SensorManager manager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    List<Sensor> list = manager.getSensorList(Sensor.TYPE_ALL);
    int[] types = new int[list.size()];
    String[] vendors = new String[list.size()];
    String[] names = new String[list.size()];
    float[] resolutions = new float[list.size()];
    int[] delays = new int[list.size()];
    float[] ranges = new float[list.size()];
    float[] powers = new float[list.size()];
    int i = 0;/* w  ww  .j  a  v a  2  s. co m*/
    for (Sensor sensor : list) {
        types[i] = sensor.getType();
        vendors[i] = sensor.getVendor();
        names[i] = sensor.getName();
        resolutions[i] = sensor.getResolution();
        delays[i] = sensor.getMinDelay();
        ranges[i] = sensor.getMaximumRange();
        powers[i] = sensor.getPower();
        i++;
    }
    return report(context, types, vendors, names, resolutions, delays, ranges, powers);
}

From source file:com.tritop.androsense2.fragments.SensorsList.java

private List<Map<String, String>> parseAvailableSensors(List<Sensor> sList) {
    List<Map<String, String>> mList = new Vector<Map<String, String>>();
    HashMap<String, String> mSensorInfo;
    for (Sensor sensor : sList) {
        mSensorInfo = new HashMap<String, String>();
        mSensorInfo.put(SENSOR_KEY_NAME, sensor.getName());
        mSensorInfo.put(SENSOR_KEY_VENDOR, sensor.getVendor());
        mSensorInfo.put(SENSOR_KEY_VERSION, SensorInfo.getStringType(getActivity(), sensor.getType()) + " v"
                + String.valueOf(sensor.getVersion()));
        mSensorInfo.put(SENSOR_KEY_POWER, SensorInfo.formatSensorfloat(sensor.getPower(), 4) + " mA");
        mSensorInfo.put(SENSOR_KEY_MAXRANGE,
                SensorInfo.formatSensorfloat(sensor.getMaximumRange(), 3) + " max");
        mSensorInfo.put(SENSOR_KEY_RESOLUTION,
                SensorInfo.formatSensorfloat(sensor.getResolution(), 4) + " res");
        mList.add(mSensorInfo);//from w  w  w .  j  av a2  s. c  o m
    }
    return mList;

}

From source file:com.tritop.androsense2.fragments.SensorsListFragment.java

private List<Map<String, String>> parseAvailableSensors(List<Sensor> sList) {
    List<Map<String, String>> mList = new Vector<Map<String, String>>();
    HashMap<String, String> mSensorInfo;
    for (Sensor sensor : sList) {
        Log.d("SENSORLIST", sensor.getName());
        mSensorInfo = new HashMap<String, String>();
        mSensorInfo.put(SENSOR_KEY_NAME, sensor.getName());
        mSensorInfo.put(SENSOR_KEY_VENDOR, sensor.getVendor());
        mSensorInfo.put(SENSOR_KEY_VERSION, SensorInfo.getStringType(getActivity(), sensor.getType()) + " v"
                + String.valueOf(sensor.getVersion()));
        mSensorInfo.put(SENSOR_KEY_POWER, SensorInfo.formatSensorfloat(sensor.getPower(), 4) + " mA");
        mSensorInfo.put(SENSOR_KEY_MAXRANGE,
                SensorInfo.formatSensorfloat(sensor.getMaximumRange(), 3) + " max");
        mSensorInfo.put(SENSOR_KEY_RESOLUTION,
                SensorInfo.formatSensorfloat(sensor.getResolution(), 4) + " res");
        mList.add(mSensorInfo);// w  w w .  j  av a 2s . com
    }
    return mList;

}

From source file:ch.bfh.sensordataprocessor.sensor.SensorDisplayFragment.java

public void displaySensor(Sensor sensor) {
    if (BuildConfig.DEBUG) {
        Log.d(TAG, "display the sensor");
    }/*from  w ww  .  j  a v  a  2 s  .  c o  m*/

    this.sensor = sensor;

    name.setText(sensor.getName());
    type.setText(String.valueOf(sensor.getType()));
    maxRange.setText(String.valueOf(sensor.getMaximumRange()));
    minDelay.setText(String.valueOf(sensor.getMinDelay()));
    power.setText(String.valueOf(sensor.getPower()));
    resolution.setText(String.valueOf(sensor.getResolution()));
    vendor.setText(String.valueOf(sensor.getVendor()));
    version.setText(String.valueOf(sensor.getVersion()));

    sensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_NORMAL);
}

From source file:github.nisrulz.projecteasydeviceinfo.MainActivity.java

@TargetApi(Build.VERSION_CODES.LOLLIPOP_MR1)
@Override//  ww  w.j a  v a 2 s. c o  m
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    //Data Array List of Info Object
    final ArrayList<String> data = new ArrayList<>();

    //Add Data
    ArrayMap<String, String> deviceDataMap = new ArrayMap<>();

    // Setup the value to be returned when result is either not found or invalid/null
    EasyDeviceInfo.setNotFoundVal("na");
    // Enable Debugging when in Debug build
    if (BuildConfig.DEBUG) {
        EasyDeviceInfo.debug();
    }

    // Library Info
    data.add(EasyDeviceInfo.getLibraryVersion());

    // ID Mod
    EasyIdMod easyIdMod = new EasyIdMod(this);

    String[] emailIds = easyIdMod.getAccounts();
    StringBuilder emailString = new StringBuilder();
    if (emailIds != null && emailIds.length > 0) {
        for (String e : emailIds) {
            emailString.append(e).append("\n");
        }
    } else {
        emailString.append("-");
    }

    EasyAdsMod easyAdsMod = new EasyAdsMod(this);
    easyAdsMod.getAndroidAdId(new EasyAdsMod.AdIdentifierCallback() {
        @Override
        public void onSuccess(String adIdentifier, boolean adDonotTrack) {
            // Add Data
            data.add("Android Advertiser ID :" + adIdentifier);
            data.add("Ad Do not Track :" + adDonotTrack);
            adapter.notifyDataSetChanged();
        }
    });

    // Config Mod
    EasyConfigMod easyConfigMod = new EasyConfigMod(this);
    deviceDataMap.put("Time (ms)", String.valueOf(easyConfigMod.getTime()));
    deviceDataMap.put("Formatted Time (24Hrs)", easyConfigMod.getFormattedTime());
    deviceDataMap.put("UpTime (ms)", String.valueOf(easyConfigMod.getUpTime()));
    deviceDataMap.put("Formatted Up Time (24Hrs)", easyConfigMod.getFormattedUpTime());
    deviceDataMap.put("Date", String.valueOf(easyConfigMod.getCurrentDate()));
    deviceDataMap.put("Formatted Date", easyConfigMod.getFormattedDate());
    deviceDataMap.put("SD Card available", String.valueOf(easyConfigMod.hasSdCard()));
    deviceDataMap.put("Running on emulator", String.valueOf(easyConfigMod.isRunningOnEmulator()));

    @RingerMode
    int ringermode = easyConfigMod.getDeviceRingerMode();
    switch (ringermode) {
    case RingerMode.NORMAL:
        deviceDataMap.put(getString(R.string.ringer_mode), "normal");
        break;
    case RingerMode.VIBRATE:
        deviceDataMap.put(getString(R.string.ringer_mode), "vibrate");
        break;
    case RingerMode.SILENT:
    default:
        deviceDataMap.put(getString(R.string.ringer_mode), "silent");
        break;
    }

    // Fingerprint Mod
    EasyFingerprintMod easyFingerprintMod = new EasyFingerprintMod(this);
    deviceDataMap.put("Is Fingerprint Sensor present?",
            String.valueOf(easyFingerprintMod.isFingerprintSensorPresent()));
    deviceDataMap.put("Are fingerprints enrolled",
            String.valueOf(easyFingerprintMod.areFingerprintsEnrolled()));

    // Sensor Mod
    EasySensorMod easySensorMod = new EasySensorMod(this);
    List<Sensor> list = easySensorMod.getAllSensors();
    for (Sensor s : list) {
        if (s != null) {
            StringBuilder stringBuilder = new StringBuilder().append("\nVendor : ").append(s.getVendor())
                    .append("\n").append("Version : ").append(s.getVersion()).append("\n").append("Power : ")
                    .append(s.getPower()).append("\n").append("Resolution : ").append(s.getResolution())
                    .append("\n").append("Max Range : ").append(s.getMaximumRange());
            deviceDataMap.put("Sensor Name - " + s.getName(), stringBuilder.toString());
        } else {
            deviceDataMap.put("Sensor", "N/A");
        }
    }

    // SIM Mod
    EasySimMod easySimMod = new EasySimMod(this);
    deviceDataMap.put("IMSI", easySimMod.getIMSI());
    deviceDataMap.put("SIM Serial Number", easySimMod.getSIMSerial());
    deviceDataMap.put("Country", easySimMod.getCountry());
    deviceDataMap.put("Carrier", easySimMod.getCarrier());
    deviceDataMap.put("SIM Network Locked", String.valueOf(easySimMod.isSimNetworkLocked()));
    deviceDataMap.put("Is Multi SIM", String.valueOf(easySimMod.isMultiSim()));
    deviceDataMap.put("Number of active SIM", String.valueOf(easySimMod.getNumberOfActiveSim()));

    if (easySimMod.isMultiSim()) {
        List<SubscriptionInfo> activeMultiSimInfo = easySimMod.getActiveMultiSimInfo();
        if (activeMultiSimInfo != null) {
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < activeMultiSimInfo.size(); i++) {
                stringBuilder.append("\nSIM ").append(i).append(" Info").append("\nPhone Number :")
                        .append(activeMultiSimInfo.get(i).getNumber()).append("\n").append("Carrier Name :")
                        .append(activeMultiSimInfo.get(i).getCarrierName()).append("\n").append("Country :")
                        .append(activeMultiSimInfo.get(i).getCountryIso()).append("\n").append("Roaming :")
                        .append(activeMultiSimInfo.get(i)
                                .getDataRoaming() == SubscriptionManager.DATA_ROAMING_ENABLE)
                        .append("\n").append("Display Name :")
                        .append(activeMultiSimInfo.get(i).getDisplayName()).append("\n").append("Sim Slot  :")
                        .append(activeMultiSimInfo.get(i).getSimSlotIndex()).append("\n");
            }
            deviceDataMap.put("Multi SIM Info", stringBuilder.toString());
        }
    }

    // Device Mod
    EasyDeviceMod easyDeviceMod = new EasyDeviceMod(this);
    deviceDataMap.put("Language", easyDeviceMod.getLanguage());
    deviceDataMap.put("Android ID", easyIdMod.getAndroidID());
    deviceDataMap.put("IMEI", easyDeviceMod.getIMEI());
    deviceDataMap.put("User-Agent", easyIdMod.getUA());
    deviceDataMap.put("GSF ID", easyIdMod.getGSFID());
    deviceDataMap.put("Pseudo ID", easyIdMod.getPseudoUniqueID());
    deviceDataMap.put("Device Serial", easyDeviceMod.getSerial());
    deviceDataMap.put("Manufacturer", easyDeviceMod.getManufacturer());
    deviceDataMap.put("Model", easyDeviceMod.getModel());
    deviceDataMap.put("OS Codename", easyDeviceMod.getOSCodename());
    deviceDataMap.put("OS Version", easyDeviceMod.getOSVersion());
    deviceDataMap.put("Display Version", easyDeviceMod.getDisplayVersion());
    deviceDataMap.put("Phone Number", easyDeviceMod.getPhoneNo());
    deviceDataMap.put("Radio Version", easyDeviceMod.getRadioVer());
    deviceDataMap.put("Product ", easyDeviceMod.getProduct());
    deviceDataMap.put("Device", easyDeviceMod.getDevice());
    deviceDataMap.put("Board", easyDeviceMod.getBoard());
    deviceDataMap.put("Hardware", easyDeviceMod.getHardware());
    deviceDataMap.put("BootLoader", easyDeviceMod.getBootloader());
    deviceDataMap.put("Device Rooted", String.valueOf(easyDeviceMod.isDeviceRooted()));
    deviceDataMap.put("Fingerprint", easyDeviceMod.getFingerprint());
    deviceDataMap.put("Build Brand", easyDeviceMod.getBuildBrand());
    deviceDataMap.put("Build Host", easyDeviceMod.getBuildHost());
    deviceDataMap.put("Build Tag", easyDeviceMod.getBuildTags());
    deviceDataMap.put("Build Time", String.valueOf(easyDeviceMod.getBuildTime()));
    deviceDataMap.put("Build User", easyDeviceMod.getBuildUser());
    deviceDataMap.put("Build Version Release", easyDeviceMod.getBuildVersionRelease());
    deviceDataMap.put("Screen Display ID", easyDeviceMod.getScreenDisplayID());
    deviceDataMap.put("Build Version Codename", easyDeviceMod.getBuildVersionCodename());
    deviceDataMap.put("Build Version Increment", easyDeviceMod.getBuildVersionIncremental());
    deviceDataMap.put("Build Version SDK", String.valueOf(easyDeviceMod.getBuildVersionSDK()));
    deviceDataMap.put("Build ID", easyDeviceMod.getBuildID());

    @DeviceType
    int deviceType = easyDeviceMod.getDeviceType(this);
    switch (deviceType) {
    case DeviceType.WATCH:
        deviceDataMap.put(getString(R.string.device_type), "watch");
        break;
    case DeviceType.PHONE:
        deviceDataMap.put(getString(R.string.device_type), "phone");
        break;
    case DeviceType.PHABLET:
        deviceDataMap.put(getString(R.string.device_type), "phablet");
        break;
    case DeviceType.TABLET:
        deviceDataMap.put(getString(R.string.device_type), "tablet");
        break;
    case DeviceType.TV:
        deviceDataMap.put(getString(R.string.device_type), "tv");
        break;
    default:
        //do nothing
        break;
    }

    @PhoneType
    int phoneType = easyDeviceMod.getPhoneType();
    switch (phoneType) {

    case PhoneType.CDMA:
        deviceDataMap.put(getString(R.string.phone_type), "CDMA");
        break;
    case PhoneType.GSM:
        deviceDataMap.put(getString(R.string.phone_type), "GSM");
        break;
    case PhoneType.NONE:
        deviceDataMap.put(getString(R.string.phone_type), "None");
        break;
    default:
        deviceDataMap.put(getString(R.string.phone_type), "Unknown");
        break;
    }

    @OrientationType
    int orientationType = easyDeviceMod.getOrientation(this);
    switch (orientationType) {
    case OrientationType.LANDSCAPE:
        deviceDataMap.put(getString(R.string.orientation), "Landscape");
        break;
    case OrientationType.PORTRAIT:
        deviceDataMap.put(getString(R.string.orientation), "Portrait");
        break;
    case OrientationType.UNKNOWN:
    default:
        deviceDataMap.put(getString(R.string.orientation), "Unknown");
        break;
    }

    // App Mod
    EasyAppMod easyAppMod = new EasyAppMod(this);
    deviceDataMap.put("Installer Store", easyAppMod.getStore());
    deviceDataMap.put("App Name", easyAppMod.getAppName());
    deviceDataMap.put("Package Name", easyAppMod.getPackageName());
    deviceDataMap.put("Activity Name", easyAppMod.getActivityName());
    deviceDataMap.put("App version", easyAppMod.getAppVersion());
    deviceDataMap.put("App versioncode", easyAppMod.getAppVersionCode());
    deviceDataMap.put("Does app have Camera permission?",
            String.valueOf(easyAppMod.isPermissionGranted(Manifest.permission.CAMERA)));

    //Network Mod
    EasyNetworkMod easyNetworkMod = new EasyNetworkMod(this);
    deviceDataMap.put("WIFI MAC Address", easyNetworkMod.getWifiMAC());
    deviceDataMap.put("WIFI LinkSpeed", easyNetworkMod.getWifiLinkSpeed());
    deviceDataMap.put("WIFI SSID", easyNetworkMod.getWifiSSID());
    deviceDataMap.put("WIFI BSSID", easyNetworkMod.getWifiBSSID());
    deviceDataMap.put("IPv4 Address", easyNetworkMod.getIPv4Address());
    deviceDataMap.put("IPv6 Address", easyNetworkMod.getIPv6Address());
    deviceDataMap.put("Network Available", String.valueOf(easyNetworkMod.isNetworkAvailable()));
    deviceDataMap.put("Wi-Fi enabled", String.valueOf(easyNetworkMod.isWifiEnabled()));

    @NetworkType
    int networkType = easyNetworkMod.getNetworkType();

    switch (networkType) {
    case NetworkType.CELLULAR_UNKNOWN:
        deviceDataMap.put(getString(R.string.network_type), "Cellular Unknown");
        break;
    case NetworkType.CELLULAR_UNIDENTIFIED_GEN:
        deviceDataMap.put(getString(R.string.network_type), "Cellular Unidentified Generation");
        break;
    case NetworkType.CELLULAR_2G:
        deviceDataMap.put(getString(R.string.network_type), "Cellular 2G");
        break;
    case NetworkType.CELLULAR_3G:
        deviceDataMap.put(getString(R.string.network_type), "Cellular 3G");
        break;
    case NetworkType.CELLULAR_4G:
        deviceDataMap.put(getString(R.string.network_type), "Cellular 4G");
        break;

    case NetworkType.WIFI_WIFIMAX:
        deviceDataMap.put(getString(R.string.network_type), "Wifi/WifiMax");
        break;
    case NetworkType.UNKNOWN:
    default:
        deviceDataMap.put(getString(R.string.network_type), "Unknown");
        break;
    }

    // Battery Mod
    EasyBatteryMod easyBatteryMod = new EasyBatteryMod(this);
    deviceDataMap.put("Battery Percentage", String.valueOf(easyBatteryMod.getBatteryPercentage()) + "%");
    deviceDataMap.put("Is device charging", String.valueOf(easyBatteryMod.isDeviceCharging()));
    deviceDataMap.put("Battery present", String.valueOf(easyBatteryMod.isBatteryPresent()));
    deviceDataMap.put("Battery technology", String.valueOf(easyBatteryMod.getBatteryTechnology()));
    deviceDataMap.put("Battery temperature", String.valueOf(easyBatteryMod.getBatteryTemperature()) + " deg C");
    deviceDataMap.put("Battery voltage", String.valueOf(easyBatteryMod.getBatteryVoltage()) + " mV");

    @BatteryHealth
    int batteryHealth = easyBatteryMod.getBatteryHealth();
    switch (batteryHealth) {
    case BatteryHealth.GOOD:
        deviceDataMap.put("Battery health", "Good");
        break;
    case BatteryHealth.HAVING_ISSUES:
    default:
        deviceDataMap.put("Battery health", "Having issues");
        break;
    }

    @ChargingVia
    int isChargingVia = easyBatteryMod.getChargingSource();
    switch (isChargingVia) {
    case ChargingVia.AC:
        deviceDataMap.put(getString(R.string.device_charging_via), "AC");
        break;
    case ChargingVia.USB:
        deviceDataMap.put(getString(R.string.device_charging_via), "USB");
        break;
    case ChargingVia.WIRELESS:
        deviceDataMap.put(getString(R.string.device_charging_via), "Wireless");
        break;
    case ChargingVia.UNKNOWN_SOURCE:
    default:
        deviceDataMap.put(getString(R.string.device_charging_via), "Unknown Source");
        break;
    }

    //Bluetooth Mod
    EasyBluetoothMod easyBluetoothMod = new EasyBluetoothMod(this);
    deviceDataMap.put("BT MAC Address", easyBluetoothMod.getBluetoothMAC());

    // Display Mod
    EasyDisplayMod easyDisplayMod = new EasyDisplayMod(this);
    deviceDataMap.put("Display Resolution", easyDisplayMod.getResolution());
    deviceDataMap.put("Screen Density", easyDisplayMod.getDensity());
    deviceDataMap.put("Screen Size", String.valueOf(easyDisplayMod.getPhysicalSize()));
    deviceDataMap.put("Screen Refresh rate", String.valueOf(easyDisplayMod.getRefreshRate()) + " Hz");

    deviceDataMap.put("Email ID", emailString.toString());

    // Location Mod
    EasyLocationMod easyLocationMod = new EasyLocationMod(this);
    double[] l = easyLocationMod.getLatLong();
    String lat = String.valueOf(l[0]);
    String lon = String.valueOf(l[1]);
    deviceDataMap.put("Latitude", lat);
    deviceDataMap.put("Longitude", lon);

    // Memory Mod
    EasyMemoryMod easyMemoryMod = new EasyMemoryMod(this);
    deviceDataMap.put("Total RAM",
            String.valueOf(easyMemoryMod.convertToGb(easyMemoryMod.getTotalRAM())) + " Gb");
    deviceDataMap.put("Available Internal Memory",
            String.valueOf(easyMemoryMod.convertToGb(easyMemoryMod.getAvailableInternalMemorySize())) + " Gb");
    deviceDataMap.put("Available External Memory",
            String.valueOf(easyMemoryMod.convertToGb(easyMemoryMod.getAvailableExternalMemorySize())) + " Gb");
    deviceDataMap.put("Total Internal Memory",
            String.valueOf(easyMemoryMod.convertToGb(easyMemoryMod.getTotalInternalMemorySize())) + " Gb");
    deviceDataMap.put("Total External memory",
            String.valueOf(easyMemoryMod.convertToGb(easyMemoryMod.getTotalExternalMemorySize())) + " Gb");

    // CPU Mod
    EasyCpuMod easyCpuMod = new EasyCpuMod();
    deviceDataMap.put("Supported ABIS", easyCpuMod.getStringSupportedABIS());
    deviceDataMap.put("Supported 32 bit ABIS", easyCpuMod.getStringSupported32bitABIS());
    deviceDataMap.put("Supported 64 bit ABIS", easyCpuMod.getStringSupported64bitABIS());

    // NFC Mod
    EasyNfcMod easyNfcMod = new EasyNfcMod(this);
    deviceDataMap.put("is NFC present", String.valueOf(easyNfcMod.isNfcPresent()));
    deviceDataMap.put("is NFC enabled", String.valueOf(easyNfcMod.isNfcEnabled()));

    for (String key : deviceDataMap.keySet()) {
        data.add(key + " : " + deviceDataMap.get(key));
    }

    ListView lv = (ListView) findViewById(R.id.listview);
    adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, data);
    lv.setAdapter(adapter);
}

From source file:org.openchaos.android.fooping.service.PingService.java

@Override
protected void onHandleIntent(Intent intent) {
    String clientID = prefs.getString("ClientID", "unknown");
    long ts = System.currentTimeMillis();

    Log.d(tag, "onHandleIntent()");

    // always send ping
    if (true) {/*from  www . j a v a  2  s .c  o m*/
        try {
            JSONObject json = new JSONObject();
            json.put("client", clientID);
            json.put("type", "ping");
            json.put("ts", ts);

            sendMessage(json);
        } catch (Exception e) {
            Log.e(tag, e.toString());
            e.printStackTrace();
        }
    }

    // http://developer.android.com/training/monitoring-device-state/battery-monitoring.html
    // http://developer.android.com/reference/android/os/BatteryManager.html
    if (prefs.getBoolean("UseBattery", false)) {
        try {
            JSONObject json = new JSONObject();
            json.put("client", clientID);
            json.put("type", "battery");
            json.put("ts", ts);

            Intent batteryStatus = registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
            if (batteryStatus != null) {
                JSONObject bat_data = new JSONObject();

                int level = batteryStatus.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
                int scale = batteryStatus.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
                if (level >= 0 && scale > 0) {
                    bat_data.put("pct", roundValue(((double) level / (double) scale) * 100, 2));
                } else {
                    Log.w(tag, "Battery level unknown");
                    bat_data.put("pct", -1);
                }
                bat_data.put("health", batteryStatus.getIntExtra(BatteryManager.EXTRA_HEALTH, -1));
                bat_data.put("status", batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS, -1));
                bat_data.put("plug", batteryStatus.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1));
                bat_data.put("volt", batteryStatus.getIntExtra(BatteryManager.EXTRA_VOLTAGE, -1));
                bat_data.put("temp", batteryStatus.getIntExtra(BatteryManager.EXTRA_TEMPERATURE, -1));
                bat_data.put("tech", batteryStatus.getStringExtra(BatteryManager.EXTRA_TECHNOLOGY));
                // bat_data.put("present", batteryStatus.getBooleanExtra(BatteryManager.EXTRA_PRESENT, false));

                json.put("battery", bat_data);
            }

            sendMessage(json);
        } catch (Exception e) {
            Log.e(tag, e.toString());
            e.printStackTrace();
        }
    }

    // http://developer.android.com/guide/topics/location/strategies.html
    // http://developer.android.com/reference/android/location/LocationManager.html
    if (prefs.getBoolean("UseGPS", false)) {
        try {
            JSONObject json = new JSONObject();
            json.put("client", clientID);
            json.put("type", "loc_gps");
            json.put("ts", ts);

            if (lm == null) {
                lm = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
            }

            Location last_loc = lm.getLastKnownLocation(LocationManager.GPS_PROVIDER);
            if (last_loc != null) {
                JSONObject loc_data = new JSONObject();

                loc_data.put("ts", last_loc.getTime());
                loc_data.put("lat", last_loc.getLatitude());
                loc_data.put("lon", last_loc.getLongitude());
                if (last_loc.hasAltitude())
                    loc_data.put("alt", roundValue(last_loc.getAltitude(), 4));
                if (last_loc.hasAccuracy())
                    loc_data.put("acc", roundValue(last_loc.getAccuracy(), 4));
                if (last_loc.hasSpeed())
                    loc_data.put("speed", roundValue(last_loc.getSpeed(), 4));
                if (last_loc.hasBearing())
                    loc_data.put("bearing", roundValue(last_loc.getBearing(), 4));

                json.put("loc_gps", loc_data);
            }

            sendMessage(json);
        } catch (Exception e) {
            Log.e(tag, e.toString());
            e.printStackTrace();
        }
    }

    if (prefs.getBoolean("UseNetwork", false)) {
        try {
            JSONObject json = new JSONObject();
            json.put("client", clientID);
            json.put("type", "loc_net");
            json.put("ts", ts);

            if (lm == null) {
                lm = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
            }

            Location last_loc = lm.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
            if (last_loc != null) {
                JSONObject loc_data = new JSONObject();

                loc_data.put("ts", last_loc.getTime());
                loc_data.put("lat", last_loc.getLatitude());
                loc_data.put("lon", last_loc.getLongitude());
                if (last_loc.hasAltitude())
                    loc_data.put("alt", roundValue(last_loc.getAltitude(), 4));
                if (last_loc.hasAccuracy())
                    loc_data.put("acc", roundValue(last_loc.getAccuracy(), 4));
                if (last_loc.hasSpeed())
                    loc_data.put("speed", roundValue(last_loc.getSpeed(), 4));
                if (last_loc.hasBearing())
                    loc_data.put("bearing", roundValue(last_loc.getBearing(), 4));

                json.put("loc_net", loc_data);
            }

            sendMessage(json);
        } catch (Exception e) {
            Log.e(tag, e.toString());
            e.printStackTrace();
        }
    }

    // http://developer.android.com/reference/android/net/wifi/WifiManager.html
    if (prefs.getBoolean("UseWIFI", false)) {
        try {
            JSONObject json = new JSONObject();
            json.put("client", clientID);
            json.put("type", "wifi");
            json.put("ts", ts);

            if (wm == null) {
                wm = (WifiManager) getSystemService(Context.WIFI_SERVICE);
            }

            List<ScanResult> wifiScan = wm.getScanResults();
            if (wifiScan != null) {
                JSONArray wifi_list = new JSONArray();

                for (ScanResult wifi : wifiScan) {
                    JSONObject wifi_data = new JSONObject();

                    wifi_data.put("BSSID", wifi.BSSID);
                    wifi_data.put("SSID", wifi.SSID);
                    wifi_data.put("freq", wifi.frequency);
                    wifi_data.put("level", wifi.level);
                    // wifi_data.put("cap", wifi.capabilities);
                    // wifi_data.put("ts", wifi.timestamp);

                    wifi_list.put(wifi_data);
                }

                json.put("wifi", wifi_list);
            }

            sendMessage(json);
        } catch (Exception e) {
            Log.e(tag, e.toString());
            e.printStackTrace();
        }
    }

    // TODO: cannot poll sensors. register receiver to cache sensor data
    // http://developer.android.com/guide/topics/sensors/sensors_overview.html
    // http://developer.android.com/reference/android/hardware/SensorManager.html
    if (prefs.getBoolean("UseSensors", false)) {
        try {
            JSONObject json = new JSONObject();
            json.put("client", clientID);
            json.put("type", "sensors");
            json.put("ts", ts);

            if (sm == null) {
                sm = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
            }

            List<Sensor> sensors = sm.getSensorList(Sensor.TYPE_ALL);
            if (sensors != null) {
                JSONArray sensor_list = new JSONArray();

                for (Sensor sensor : sensors) {
                    JSONObject sensor_info = new JSONObject();

                    sensor_info.put("name", sensor.getName());
                    sensor_info.put("type", sensor.getType());
                    sensor_info.put("vendor", sensor.getVendor());
                    sensor_info.put("version", sensor.getVersion());
                    sensor_info.put("power", roundValue(sensor.getPower(), 4));
                    sensor_info.put("resolution", roundValue(sensor.getResolution(), 4));
                    sensor_info.put("range", roundValue(sensor.getMaximumRange(), 4));

                    sensor_list.put(sensor_info);
                }

                json.put("sensors", sensor_list);
            }

            sendMessage(json);
        } catch (Exception e) {
            Log.e(tag, e.toString());
            e.printStackTrace();
        }
    }

    // http://developer.android.com/training/monitoring-device-state/connectivity-monitoring.html
    // http://developer.android.com/reference/android/net/ConnectivityManager.html
    if (prefs.getBoolean("UseConn", false)) {
        try {
            JSONObject json = new JSONObject();
            json.put("client", clientID);
            json.put("type", "conn");
            json.put("ts", ts);

            if (cm == null) {
                cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
            }

            // TODO: add active/all preferences below UseConn
            if (prefs.getBoolean("UseConnActive", true)) {
                NetworkInfo net = cm.getActiveNetworkInfo();
                if (net != null) {
                    JSONObject net_data = new JSONObject();

                    net_data.put("type", net.getTypeName());
                    net_data.put("subtype", net.getSubtypeName());
                    net_data.put("connected", net.isConnected());
                    net_data.put("available", net.isAvailable());
                    net_data.put("roaming", net.isRoaming());
                    net_data.put("failover", net.isFailover());
                    if (net.getReason() != null)
                        net_data.put("reason", net.getReason());
                    if (net.getExtraInfo() != null)
                        net_data.put("extra", net.getExtraInfo());

                    json.put("conn_active", net_data);
                }
            }

            if (prefs.getBoolean("UseConnAll", false)) {
                NetworkInfo[] nets = cm.getAllNetworkInfo();
                if (nets != null) {
                    JSONArray net_list = new JSONArray();

                    for (NetworkInfo net : nets) {
                        JSONObject net_data = new JSONObject();

                        net_data.put("type", net.getTypeName());
                        net_data.put("subtype", net.getSubtypeName());
                        net_data.put("connected", net.isConnected());
                        net_data.put("available", net.isAvailable());
                        net_data.put("roaming", net.isRoaming());
                        net_data.put("failover", net.isFailover());
                        if (net.getReason() != null)
                            net_data.put("reason", net.getReason());
                        if (net.getExtraInfo() != null)
                            net_data.put("extra", net.getExtraInfo());

                        net_list.put(net_data);
                    }

                    json.put("conn_all", net_list);
                }
            }

            sendMessage(json);
        } catch (Exception e) {
            Log.e(tag, e.toString());
            e.printStackTrace();
        }
    }

    if (!PingServiceReceiver.completeWakefulIntent(intent)) {
        Log.w(tag, "completeWakefulIntent() failed. no active wake lock?");
    }
}

From source file:com.aware.Aware_Preferences.java

/**
 * Gravity module settings UI//from   w ww  .j av  a  2  s  . c  om
 */
private void gravity() {
    final PreferenceScreen grav_pref = (PreferenceScreen) findPreference("gravity");
    Sensor temp = mSensorMgr.getDefaultSensor(Sensor.TYPE_GRAVITY);
    if (temp != null) {
        grav_pref.setSummary(
                grav_pref.getSummary().toString().replace("*", " - Power: " + temp.getPower() + " mA"));
    } else {
        grav_pref.setSummary(grav_pref.getSummary().toString().replace("*", ""));
    }

    final CheckBoxPreference gravity = (CheckBoxPreference) findPreference(Aware_Preferences.STATUS_GRAVITY);
    gravity.setChecked(
            Aware.getSetting(getApplicationContext(), Aware_Preferences.STATUS_GRAVITY).equals("true"));
    gravity.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
        @Override
        public boolean onPreferenceClick(Preference preference) {

            if (mSensorMgr.getDefaultSensor(Sensor.TYPE_GRAVITY) == null) {
                showDialog(DIALOG_ERROR_MISSING_SENSOR);
                gravity.setChecked(false);
                Aware.setSetting(getApplicationContext(), Aware_Preferences.STATUS_GRAVITY, false);
                return false;
            }
            Aware.setSetting(getApplicationContext(), Aware_Preferences.STATUS_GRAVITY, gravity.isChecked());
            if (gravity.isChecked()) {
                framework.startGravity();
            } else {
                framework.stopGravity();
            }
            return true;
        }
    });

    final EditTextPreference frequency_gravity = (EditTextPreference) findPreference(
            Aware_Preferences.FREQUENCY_GRAVITY);
    if (Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_GRAVITY).length() > 0) {
        frequency_gravity
                .setSummary(Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_GRAVITY)
                        + " microseconds");
    }
    frequency_gravity.setText(Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_GRAVITY));
    frequency_gravity.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            Aware.setSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_GRAVITY, (String) newValue);
            frequency_gravity.setSummary((String) newValue + " microseconds");
            framework.startGravity();
            return true;
        }
    });
}

From source file:com.aware.Aware_Preferences.java

/**
 * Light module settings UI// w w  w .ja  v  a2s . co m
 */
private void light() {

    final PreferenceScreen light_pref = (PreferenceScreen) findPreference("light");
    Sensor temp = mSensorMgr.getDefaultSensor(Sensor.TYPE_LIGHT);
    if (temp != null) {
        light_pref.setSummary(
                light_pref.getSummary().toString().replace("*", " - Power: " + temp.getPower() + " mA"));
    } else {
        light_pref.setSummary(light_pref.getSummary().toString().replace("*", ""));
    }

    final CheckBoxPreference light = (CheckBoxPreference) findPreference(Aware_Preferences.STATUS_LIGHT);
    light.setChecked(Aware.getSetting(getApplicationContext(), Aware_Preferences.STATUS_LIGHT).equals("true"));
    light.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
        @Override
        public boolean onPreferenceClick(Preference preference) {
            if (mSensorMgr.getDefaultSensor(Sensor.TYPE_LIGHT) == null) {
                showDialog(DIALOG_ERROR_MISSING_SENSOR);
                light.setChecked(false);
                Aware.setSetting(getApplicationContext(), Aware_Preferences.STATUS_LIGHT, false);
                return false;
            }

            Aware.setSetting(getApplicationContext(), Aware_Preferences.STATUS_LIGHT, light.isChecked());
            if (light.isChecked()) {
                framework.startLight();
            } else {
                framework.stopLight();
            }
            return true;
        }
    });

    final EditTextPreference frequency_light = (EditTextPreference) findPreference(
            Aware_Preferences.FREQUENCY_LIGHT);
    if (Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_LIGHT).length() > 0) {
        frequency_light.setSummary(
                Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_LIGHT) + " microseconds");
    }
    frequency_light.setText(Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_LIGHT));
    frequency_light.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            Aware.setSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_LIGHT, (String) newValue);
            frequency_light.setSummary((String) newValue + " microseconds");
            framework.startLight();
            return true;
        }
    });

}

From source file:com.aware.Aware_Preferences.java

/**
 * Atmospheric Pressure module settings UI
 *//*from  w w w .j  a  v  a  2  s.  c  o  m*/
private void barometer() {
    final PreferenceScreen baro_pref = (PreferenceScreen) findPreference("barometer");
    Sensor temp = mSensorMgr.getDefaultSensor(Sensor.TYPE_PRESSURE);
    if (temp != null) {
        baro_pref.setSummary(
                baro_pref.getSummary().toString().replace("*", " - Power: " + temp.getPower() + " mA"));
    } else {
        baro_pref.setSummary(baro_pref.getSummary().toString().replace("*", ""));
    }

    final CheckBoxPreference pressure = (CheckBoxPreference) findPreference(Aware_Preferences.STATUS_BAROMETER);
    pressure.setChecked(
            Aware.getSetting(getApplicationContext(), Aware_Preferences.STATUS_BAROMETER).equals("true"));
    pressure.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
        @Override
        public boolean onPreferenceClick(Preference preference) {

            if (mSensorMgr.getDefaultSensor(Sensor.TYPE_PRESSURE) == null) {
                showDialog(DIALOG_ERROR_MISSING_SENSOR);
                pressure.setChecked(false);
                Aware.setSetting(getApplicationContext(), Aware_Preferences.STATUS_BAROMETER, false);
                return false;
            }

            Aware.setSetting(getApplicationContext(), Aware_Preferences.STATUS_BAROMETER, pressure.isChecked());
            if (pressure.isChecked()) {
                framework.startBarometer();
            } else {
                framework.stopBarometer();
            }
            return true;
        }
    });

    final EditTextPreference frequency_pressure = (EditTextPreference) findPreference(
            Aware_Preferences.FREQUENCY_BAROMETER);
    if (Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_BAROMETER).length() > 0) {
        frequency_pressure
                .setSummary(Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_BAROMETER)
                        + " microseconds");
    }
    frequency_pressure
            .setText(Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_BAROMETER));
    frequency_pressure.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            Aware.setSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_BAROMETER, (String) newValue);
            frequency_pressure.setSummary((String) newValue + " microseconds");
            framework.startBarometer();
            return true;
        }
    });

}

From source file:com.aware.Aware_Preferences.java

/**
 * Gyroscope module settings UI//  w  ww .j a  v a2s.c o  m
 */
private void gyroscope() {
    final PreferenceScreen gyro_pref = (PreferenceScreen) findPreference("gyroscope");
    Sensor temp = mSensorMgr.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
    if (temp != null) {
        gyro_pref.setSummary(
                gyro_pref.getSummary().toString().replace("*", " - Power: " + temp.getPower() + " mA"));
    } else {
        gyro_pref.setSummary(gyro_pref.getSummary().toString().replace("*", ""));
    }

    final CheckBoxPreference gyroscope = (CheckBoxPreference) findPreference(
            Aware_Preferences.STATUS_GYROSCOPE);
    gyroscope.setChecked(
            Aware.getSetting(getApplicationContext(), Aware_Preferences.STATUS_GYROSCOPE).equals("true"));
    gyroscope.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
        @Override
        public boolean onPreferenceClick(Preference preference) {

            if (mSensorMgr.getDefaultSensor(Sensor.TYPE_GYROSCOPE) == null) {
                showDialog(DIALOG_ERROR_MISSING_SENSOR);
                gyroscope.setChecked(false);
                Aware.setSetting(getApplicationContext(), Aware_Preferences.STATUS_GYROSCOPE, false);
                return false;
            }
            Aware.setSetting(getApplicationContext(), Aware_Preferences.STATUS_GYROSCOPE,
                    gyroscope.isChecked());
            if (gyroscope.isChecked()) {
                framework.startGyroscope();
            } else {
                framework.stopGyroscope();
            }
            return true;
        }
    });

    final EditTextPreference frequency_gyroscope = (EditTextPreference) findPreference(
            Aware_Preferences.FREQUENCY_GYROSCOPE);
    if (Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_GYROSCOPE).length() > 0) {
        frequency_gyroscope
                .setSummary(Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_GYROSCOPE)
                        + " microseconds");
    }
    frequency_gyroscope
            .setText(Aware.getSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_GYROSCOPE));
    frequency_gyroscope.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
        @Override
        public boolean onPreferenceChange(Preference preference, Object newValue) {
            Aware.setSetting(getApplicationContext(), Aware_Preferences.FREQUENCY_GYROSCOPE, (String) newValue);
            frequency_gyroscope.setSummary((String) newValue + " microseconds");
            framework.startGyroscope();
            return true;
        }
    });

}