public boolean onPreferenceChange(Preference arg0, Object arg1) { final String key = arg0.getKey(); if (KEY_NETWORK_MODE_SETTING.equals(key)) { int oldNetworkMode = android.provider.Settings.Secure.getInt( getContentResolver(), Settings.Secure.PREFERRED_NETWORK_MODE, preferredNetworkMode); int newNetworkMode = Integer.valueOf((String) arg1).intValue(); newNetworkMode = GeminiUtils.getNetworkMode(newNetworkMode); Settings.Secure.putInt( getContentResolver(), Settings.Secure.PREFERRED_NETWORK_MODE, newNetworkMode); if (newNetworkMode != oldNetworkMode) { Intent intent = new Intent(GeminiUtils.NETWORK_MODE_CHANGE_BROADCAST, null); intent.putExtra(GeminiUtils.OLD_NETWORK_MODE, oldNetworkMode); intent.putExtra(GeminiUtils.NETWORK_MODE_CHANGE_BROADCAST, newNetworkMode); intent.putExtra(Phone.GEMINI_SIM_ID_KEY, Phone.GEMINI_SIM_1); showDialog(DIALOG_NETWORK_MODE_CHANGE); setCancelable(false); getActivity().sendBroadcast(intent); Xlog.i(TAG, "Send broadcast of " + GeminiUtils.NETWORK_MODE_CHANGE_BROADCAST); } } return true; }
public void resume() { final ContentResolver cr = mContext.getContentResolver(); cr.registerContentObserver( Settings.Secure.getUriFor(Settings.Secure.DEFAULT_INPUT_METHOD), false, this); cr.registerContentObserver( Settings.Secure.getUriFor(Settings.Secure.SELECTED_INPUT_METHOD_SUBTYPE), false, this); }
// ensure that this accessibility service is enabled. // the service watches for google voice notifications to know when to check for new // messages. private void ensureEnabled() { Set<ComponentName> enabledServices = getEnabledServicesFromSettings(); ComponentName me = new ComponentName(this, getClass()); if (enabledServices.contains(me) && connected) return; enabledServices.add(me); // Update the enabled services setting. StringBuilder enabledServicesBuilder = new StringBuilder(); // Keep the enabled services even if they are not installed since we // have no way to know whether the application restore process has // completed. In general the system should be responsible for the // clean up not settings. for (ComponentName enabledService : enabledServices) { enabledServicesBuilder.append(enabledService.flattenToString()); enabledServicesBuilder.append(ENABLED_ACCESSIBILITY_SERVICES_SEPARATOR); } final int enabledServicesBuilderLength = enabledServicesBuilder.length(); if (enabledServicesBuilderLength > 0) { enabledServicesBuilder.deleteCharAt(enabledServicesBuilderLength - 1); } Settings.Secure.putString( getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, enabledServicesBuilder.toString()); // Update accessibility enabled. Settings.Secure.putInt(getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 0); Settings.Secure.putInt(getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1); }
@Override public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) { final ContentResolver cr = getContentResolver(); final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE); if (preference == mNetwork) { if (!um.hasUserRestriction(UserManager.DISALLOW_SHARE_LOCATION)) { Settings.Secure.setLocationProviderEnabled( cr, LocationManager.NETWORK_PROVIDER, mNetwork.isChecked()); } } else if (preference == mGps) { boolean enabled = mGps.isChecked(); if (!um.hasUserRestriction(UserManager.DISALLOW_SHARE_LOCATION)) { Settings.Secure.setLocationProviderEnabled(cr, LocationManager.GPS_PROVIDER, enabled); if (mAssistedGps != null) { mAssistedGps.setEnabled(enabled); } } } else if (preference == mAssistedGps) { Settings.Global.putInt( cr, Settings.Global.ASSISTED_GPS_ENABLED, mAssistedGps.isChecked() ? 1 : 0); } else { // If we didn't handle it, let preferences handle it. return super.onPreferenceTreeClick(preferenceScreen, preference); } return true; }
@Override public int onStartCommand(Intent intent, int flags, int startId) { if (!mIsRunning) { final Context context = getApplicationContext(); mIsRunning = true; final ContentResolver contentResolver = getContentResolver(); try { mCurrentLocationmode = Settings.Secure.getInt(contentResolver, Settings.Secure.LOCATION_MODE); if (mCurrentLocationmode != Settings.Secure.LOCATION_MODE_HIGH_ACCURACY) { Settings.Secure.putInt( contentResolver, Settings.Secure.LOCATION_MODE, Settings.Secure.LOCATION_MODE_HIGH_ACCURACY); } } catch (SettingNotFoundException e) { Log.e(TAG, "Unable find location settings.", e); } int state = intent.getIntExtra(SERVICE_PARAM, Config.ANTITHEFT_STATE.NORMAL.getState()); if (state == Config.ANTITHEFT_STATE.THEFT.getState()) { mConstantReporting = true; } buildGoogleApiClient(); } if (mGoogleApiClient.isConnected()) { restartLocationUpdates(); } return START_REDELIVER_INTENT; }
public String addEnableAccessibilityService(String nameService) { try { String enableSer = Settings.Secure.getString( cntx.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES); if (!enableSer.contains(nameService)) { // If not is enabled we activate the AccessibilityService // Service Settings.Secure.putInt( cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1); // Enable // accessibility Settings.Secure.putString( cntx.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, nameService); // Put // the // package // name // and // the // accesibility // service Settings.Secure.putInt( cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1); // Enable // accessibility } return MESSAGE_OK; } catch (Exception e) { e.printStackTrace(); return MESSAGE_ERROR; } }
@Override public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) { if (Utils.isMonkeyRunning()) { return false; } if (preference == mEnableAdb) { if (mEnableAdb.isChecked()) { mOkClicked = false; if (mOkDialog != null) dismissDialog(); mOkDialog = new AlertDialog.Builder(getActivity()) .setMessage(getActivity().getResources().getString(R.string.adb_warning_message)) .setTitle(R.string.adb_warning_title) .setIcon(android.R.drawable.ic_dialog_alert) .setPositiveButton(android.R.string.yes, this) .setNegativeButton(android.R.string.no, this) .show(); mOkDialog.setOnDismissListener(this); } else { Settings.Secure.putInt(getActivity().getContentResolver(), Settings.Secure.ADB_ENABLED, 0); } } else if (preference == mKeepScreenOn) { Settings.System.putInt( getActivity().getContentResolver(), Settings.System.STAY_ON_WHILE_PLUGGED_IN, mKeepScreenOn.isChecked() ? (BatteryManager.BATTERY_PLUGGED_AC | BatteryManager.BATTERY_PLUGGED_USB) : 0); } else if (preference == mAllowMockLocation) { Settings.Secure.putInt( getActivity().getContentResolver(), Settings.Secure.ALLOW_MOCK_LOCATION, mAllowMockLocation.isChecked() ? 1 : 0); } else if (preference == mStrictMode) { writeStrictModeVisualOptions(); } else if (preference == mPointerLocation) { writePointerLocationOptions(); } else if (preference == mShowTouches) { writeShowTouchesOptions(); } else if (preference == mShowScreenUpdates) { writeFlingerOptions(); } else if (preference == mShowCpuUsage) { writeCpuUsageOptions(); } else if (preference == mImmediatelyDestroyActivities) { writeImmediatelyDestroyActivitiesOptions(); } else if (preference == mShowAllANRs) { writeShowAllANRsOptions(); } else if (preference == mForceHardwareUi) { writeHardwareUiOptions(); } return false; }
String getOwnerInfo() { ContentResolver res = getContext().getContentResolver(); final boolean ownerInfoEnabled = Settings.Secure.getIntForUser( res, Settings.Secure.LOCK_SCREEN_OWNER_INFO_ENABLED, 1, UserHandle.USER_CURRENT) != 0; return ownerInfoEnabled && !mShowingMessage ? Settings.Secure.getStringForUser( res, Settings.Secure.LOCK_SCREEN_OWNER_INFO, UserHandle.USER_CURRENT) : null; }
/** Enable or disable all providers when the master toggle is changed. */ private void onToggleLocationAccess(boolean checked) { final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE); if (um.hasUserRestriction(UserManager.DISALLOW_SHARE_LOCATION)) { return; } final ContentResolver cr = getContentResolver(); Settings.Secure.setLocationProviderEnabled(cr, LocationManager.GPS_PROVIDER, checked); Settings.Secure.setLocationProviderEnabled(cr, LocationManager.NETWORK_PROVIDER, checked); updateLocationToggles(); updateLtoServiceStatus(getActivity(), checked); }
public int getPriority(BluetoothDevice device) { enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); synchronized (BluetoothHeadsetService.this) { int priority = Settings.Secure.getInt( getContentResolver(), Settings.Secure.getBluetoothHeadsetPriorityKey(device.getAddress()), BluetoothHeadset.PRIORITY_UNDEFINED); return priority; } }
private void disableNonexistentServices(int userId) { String flatIn = Settings.Secure.getStringForUser( mContext.getContentResolver(), mConfig.secureSettingName, userId); if (!TextUtils.isEmpty(flatIn)) { if (DEBUG) Slog.v(TAG, "flat before: " + flatIn); PackageManager pm = mContext.getPackageManager(); List<ResolveInfo> installedServices = pm.queryIntentServicesAsUser( new Intent(mConfig.serviceInterface), PackageManager.GET_SERVICES | PackageManager.GET_META_DATA, userId); if (DEBUG) Slog.v(TAG, mConfig.serviceInterface + " services: " + installedServices); Set<ComponentName> installed = new ArraySet<ComponentName>(); for (int i = 0, count = installedServices.size(); i < count; i++) { ResolveInfo resolveInfo = installedServices.get(i); ServiceInfo info = resolveInfo.serviceInfo; if (!mConfig.bindPermission.equals(info.permission)) { Slog.w( TAG, "Skipping " + getCaption() + " service " + info.packageName + "/" + info.name + ": it does not require the permission " + mConfig.bindPermission); continue; } installed.add(new ComponentName(info.packageName, info.name)); } String flatOut = ""; if (!installed.isEmpty()) { String[] enabled = flatIn.split(ENABLED_SERVICES_SEPARATOR); ArrayList<String> remaining = new ArrayList<String>(enabled.length); for (int i = 0; i < enabled.length; i++) { ComponentName enabledComponent = ComponentName.unflattenFromString(enabled[i]); if (installed.contains(enabledComponent)) { remaining.add(enabled[i]); } } flatOut = TextUtils.join(ENABLED_SERVICES_SEPARATOR, remaining); } if (DEBUG) Slog.v(TAG, "flat after: " + flatOut); if (!flatIn.equals(flatOut)) { Settings.Secure.putStringForUser( mContext.getContentResolver(), mConfig.secureSettingName, flatOut, userId); } } }
@Override public void onPreferenceToggled(String preferenceKey, boolean enabled) { // Parse the enabled services. Set<ComponentName> enabledServices = getEnabledServicesFromSettings(getActivity()); // Determine enabled services and accessibility state. ComponentName toggledService = ComponentName.unflattenFromString(preferenceKey); final boolean accessibilityEnabled; if (enabled) { // Enabling at least one service enables accessibility. accessibilityEnabled = true; enabledServices.add(toggledService); } else { // Check how many enabled and installed services are present. int enabledAndInstalledServiceCount = 0; Set<ComponentName> installedServices = sInstalledServices; for (ComponentName enabledService : enabledServices) { if (installedServices.contains(enabledService)) { enabledAndInstalledServiceCount++; } } // Disabling the last service disables accessibility. accessibilityEnabled = enabledAndInstalledServiceCount > 1 || (enabledAndInstalledServiceCount == 1 && !installedServices.contains(toggledService)); enabledServices.remove(toggledService); } // Update the enabled services setting. StringBuilder enabledServicesBuilder = new StringBuilder(); // Keep the enabled services even if they are not installed since we have // no way to know whether the application restore process has completed. // In general the system should be responsible for the clean up not settings. for (ComponentName enabledService : enabledServices) { enabledServicesBuilder.append(enabledService.flattenToString()); enabledServicesBuilder.append(ENABLED_ACCESSIBILITY_SERVICES_SEPARATOR); } final int enabledServicesBuilderLength = enabledServicesBuilder.length(); if (enabledServicesBuilderLength > 0) { enabledServicesBuilder.deleteCharAt(enabledServicesBuilderLength - 1); } Settings.Secure.putString( getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, enabledServicesBuilder.toString()); // Update accessibility enabled. Settings.Secure.putInt( getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, accessibilityEnabled ? 1 : 0); }
/* * Creates toggles for each available location provider */ private void updateLocationToggles() { ContentResolver res = getContentResolver(); boolean gpsEnabled = Settings.Secure.isLocationProviderEnabled(res, LocationManager.GPS_PROVIDER); mNetwork.setChecked( Settings.Secure.isLocationProviderEnabled(res, LocationManager.NETWORK_PROVIDER)); mGps.setChecked(gpsEnabled); if (mAssistedGps != null) { mAssistedGps.setChecked( Settings.Secure.getInt(res, Settings.Secure.ASSISTED_GPS_ENABLED, 2) == 1); mAssistedGps.setEnabled(gpsEnabled); } }
public void checkAccessibilityService() { int accessibilityEnabled = 0; boolean accessibilityFound = false; try { accessibilityEnabled = Settings.Secure.getInt( this.getContentResolver(), android.provider.Settings.Secure.ACCESSIBILITY_ENABLED); } catch (SettingNotFoundException e) { } TextUtils.SimpleStringSplitter mStringColonSplitter = new TextUtils.SimpleStringSplitter(':'); if (accessibilityEnabled == 1) { String settingValue = Settings.Secure.getString( getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES); if (settingValue != null) { TextUtils.SimpleStringSplitter splitter = mStringColonSplitter; splitter.setString(settingValue); while (splitter.hasNext()) { String accessabilityService = splitter.next(); if (accessabilityService.equalsIgnoreCase(Constants.ACCESSIBILITY_SERVICE)) { accessibilityFound = true; break; } } } } if (!accessibilityFound) { findViewById(R.id.tvAccessibilityError).setVisibility(View.VISIBLE); findViewById(R.id.spMode).setVisibility(View.GONE); findViewById(R.id.tvMode).setVisibility(View.GONE); findViewById(android.R.id.empty).setVisibility(View.GONE); findViewById(R.id.listPackages).setEnabled(false); if (Constants.IS_LOGGABLE) { Log.i(Constants.LOG_TAG, "The accessibility service is NOT on!"); } } else { findViewById(R.id.tvAccessibilityError).setVisibility(View.GONE); findViewById(R.id.spMode).setVisibility(View.VISIBLE); findViewById(R.id.tvMode).setVisibility(View.VISIBLE); findViewById(android.R.id.empty).setVisibility(View.VISIBLE); findViewById(R.id.listPackages).setEnabled(true); if (Constants.IS_LOGGABLE) { Log.i(Constants.LOG_TAG, "The accessibility service is on!"); } } }
/** * Gets the hardware serial number of this device. * * @return serial number or Settings.Secure.ANDROID_ID if not available. */ private static String getDeviceSerialNumber(Context context) { // We're using the Reflection API because Build.SERIAL is only available // since API Level 9 (Gingerbread, Android 2.3). try { String deviceSerial = (String) Build.class.getField("SERIAL").get(null); if (TextUtils.isEmpty(deviceSerial)) { deviceSerial = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID); } return deviceSerial; } catch (Exception ignored) { // default to Android_ID return Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID); } }
/** returns true on success, false if the user must correct something */ boolean saveToDb() { String hostname = mHostnameField.getText().toString().trim(); String portStr = mPortField.getText().toString().trim(); int port = -1; int result = validate(hostname, portStr); if (result > 0) { showError(result); return false; } if (portStr.length() > 0) { try { port = Integer.parseInt(portStr); } catch (NumberFormatException ex) { return false; } } // FIXME: The best solution would be to make a better UI that would // disable editing of the text boxes if the user chooses to use the // default settings. i.e. checking a box to always use the default // carrier. http:/b/issue?id=756480 // FIXME: This currently will not work if the default host is blank and // the user has cleared the input boxes in order to not use a proxy. // This is a UI problem and can be solved with some better form // controls. // FIXME: If the user types in a proxy that matches the default, should // we keep that setting? Can be fixed with a new UI. ContentResolver res = getContentResolver(); if (hostname.equals(Proxy.getDefaultHost()) && port == Proxy.getDefaultPort()) { // If the user hit the default button and didn't change any of // the input boxes, treat it as if the user has not specified a // proxy. hostname = null; } if (!TextUtils.isEmpty(hostname)) { hostname += ':' + portStr; } Settings.Secure.putString(res, Settings.Secure.HTTP_PROXY, hostname); Settings.Secure.putInt( res, Settings.Secure.HTTP_PROXY_WIFI_ONLY, mProxyWifiOnly.isChecked() ? 1 : 0); sendBroadcast(new Intent(Proxy.PROXY_CHANGE_ACTION)); return true; }
/** * Load the current Gservices settings for when {@link #shouldWeBeBrutalLocked} will allow the * brutality to happen. Must not be called with the lock held. */ void retrieveBrutalityAmount() { mMinScreenOff = (mReqMinScreenOff >= 0 ? mReqMinScreenOff : Settings.Secure.getInt( mResolver, Settings.Secure.MEMCHECK_MIN_SCREEN_OFF, MEMCHECK_DEFAULT_MIN_SCREEN_OFF)) * 1000; mMinAlarm = (mReqMinNextAlarm >= 0 ? mReqMinNextAlarm : Settings.Secure.getInt( mResolver, Settings.Secure.MEMCHECK_MIN_ALARM, MEMCHECK_DEFAULT_MIN_ALARM)) * 1000; }
@Override public void handleMessage(Message msg) { switch (msg.what) { case MONITOR: { // See if we should force a reboot. int rebootInterval = mReqRebootInterval >= 0 ? mReqRebootInterval : Settings.Secure.getInt( mResolver, Settings.Secure.REBOOT_INTERVAL, REBOOT_DEFAULT_INTERVAL); if (mRebootInterval != rebootInterval) { mRebootInterval = rebootInterval; // We have been running long enough that a reboot can // be considered... checkReboot(false); } final int size = mMonitors.size(); for (int i = 0; i < size; i++) { mCurrentMonitor = mMonitors.get(i); mCurrentMonitor.monitor(); } synchronized (Watchdog.this) { mCompleted = true; mCurrentMonitor = null; } } break; } }
/** * Returns the state of the GPS module. * * @param context Context of the application component * @return Current state of the GPS module */ public static boolean isGPSEnabled(Context context) { String provider = Settings.Secure.getString( context.getContentResolver(), Settings.Secure.LOCATION_PROVIDERS_ALLOWED); return provider.contains("gps"); }
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_splash); dbLogin = new DbLogin(MySplash.this, DbLogin.DB_NAME, null, DbLogin.DB_VERSION); db_read = dbLogin.getReadableDatabase(); db_write = dbLogin.getWritableDatabase(); String identifier = null; TelephonyManager tm = (TelephonyManager) this.getSystemService(this.TELEPHONY_SERVICE); if (tm != null) { identifier = tm.getDeviceId(); } if (identifier == null || identifier.length() == 0) { identifier = Settings.Secure.getString(getContentResolver(), Settings.Secure.ANDROID_ID); } Toast.makeText(MySplash.this, "Your IMEI no:" + identifier, Toast.LENGTH_LONG).show(); System.out.println("IMEI no:" + identifier); Log.d("IMEI or Android id:", identifier); Cursor cursor = dbLogin.getData(db_read); if (cursor.getCount() > 0) { Intent intent = new Intent(MySplash.this, MyLogin.class); startActivity(intent); } else { Toast.makeText(MySplash.this, "Login database is empty", Toast.LENGTH_SHORT).show(); if (identifier != null) { new AsynchLogin().execute(identifier); } else { Toast.makeText(MySplash.this, "Unable to find your IMEI no.", Toast.LENGTH_LONG).show(); } } }
@Override public void setNightMode(int mode) { switch (mode) { case UiModeManager.MODE_NIGHT_NO: case UiModeManager.MODE_NIGHT_YES: case UiModeManager.MODE_NIGHT_AUTO: break; default: throw new IllegalArgumentException("Unknown mode: " + mode); } final long ident = Binder.clearCallingIdentity(); try { synchronized (mLock) { if (isDoingNightModeLocked() && mNightMode != mode) { Settings.Secure.putInt(getContext().getContentResolver(), Settings.Secure.UI_NIGHT_MODE, mode); mNightMode = mode; updateLocked(0, 0); } } } finally { Binder.restoreCallingIdentity(ident); } }
@Override public void onStart() { final Context context = getContext(); mTwilightManager = getLocalService(TwilightManager.class); final PowerManager powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE); mWakeLock = powerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, TAG); context.registerReceiver(mDockModeReceiver, new IntentFilter(Intent.ACTION_DOCK_EVENT)); context.registerReceiver(mBatteryReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED)); mConfiguration.setToDefaults(); mDefaultUiModeType = context.getResources().getInteger( com.android.internal.R.integer.config_defaultUiModeType); mCarModeKeepsScreenOn = (context.getResources().getInteger( com.android.internal.R.integer.config_carDockKeepsScreenOn) == 1); mDeskModeKeepsScreenOn = (context.getResources().getInteger( com.android.internal.R.integer.config_deskDockKeepsScreenOn) == 1); mTelevision = context.getPackageManager().hasSystemFeature( PackageManager.FEATURE_TELEVISION) || context.getPackageManager().hasSystemFeature( PackageManager.FEATURE_LEANBACK); mWatch = context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH); mNightMode = Settings.Secure.getInt(context.getContentResolver(), Settings.Secure.UI_NIGHT_MODE, UiModeManager.MODE_NIGHT_AUTO); mTwilightManager.registerListener(mTwilightListener, mHandler); publishBinderService(Context.UI_MODE_SERVICE, mService); }
@Override protected void onResume() { super.onResume(); mEnableAdb.setChecked( Settings.Secure.getInt(getContentResolver(), Settings.Secure.ADB_ENABLED, 0) != 0); mAdbNotify.setChecked( Settings.Secure.getInt(getContentResolver(), Settings.Secure.ADB_NOTIFY, 1) != 0); mKeepScreenOn.setChecked( Settings.System.getInt(getContentResolver(), Settings.System.STAY_ON_WHILE_PLUGGED_IN, 0) != 0); mAllowMockLocation.setChecked( Settings.Secure.getInt(getContentResolver(), Settings.Secure.ALLOW_MOCK_LOCATION, 0) != 0); }
private class SettingsObserver extends ContentObserver { private final Uri mSecureSettingsUri = Settings.Secure.getUriFor(mConfig.secureSettingName); private SettingsObserver(Handler handler) { super(handler); } private void observe() { ContentResolver resolver = mContext.getContentResolver(); resolver.registerContentObserver(mSecureSettingsUri, false, this, UserHandle.USER_ALL); update(null); } @Override public void onChange(boolean selfChange, Uri uri) { update(uri); } private void update(Uri uri) { if (uri == null || mSecureSettingsUri.equals(uri)) { if (DEBUG) Slog.d( TAG, "Setting changed: mSecureSettingsUri=" + mSecureSettingsUri + " / uri=" + uri); rebindServices(); } } }
public static String getDeiceId(Context var0) { TelephonyManager var1 = (TelephonyManager) var0.getSystemService(Context.TELEPHONY_SERVICE); if (var1 == null) { YLog.e(TAG, "No IMEI."); } String var2 = ""; try { if (checkPermission(var0, "android.permission.READ_PHONE_STATE")) { var2 = var1.getDeviceId(); } } catch (Exception var4) { YLog.e(TAG, "No IMEI.--->" + var4); } if (TextUtils.isEmpty(var2)) { YLog.e(TAG, "No IMEI."); var2 = getMacAddress(var0); if (TextUtils.isEmpty(var2)) { YLog.e(TAG, "Failed to take mac as IMEI. Try to use Secure.ANDROID_ID instead."); var2 = Settings.Secure.getString(var0.getContentResolver(), "android_id"); YLog.e(TAG, "getDeviceId: Secure.ANDROID_ID: " + var2); return var2; } } return var2; }
@Override public void onResume() { // TODO Auto-generated method stub super.onResume(); int settingsNetworkMode = Settings.Secure.getInt( getContentResolver(), Settings.Secure.PREFERRED_NETWORK_MODE, preferredNetworkMode); if ((settingsNetworkMode >= 0) && (settingsNetworkMode <= 2)) { mNetworkMode.setValue(Integer.toString(settingsNetworkMode)); } if (iTelephony == null) { return; } try { boolean Sim1Insert = iTelephony.isSimInsert(Phone.GEMINI_SIM_1); boolean Sim1Ready = false; if (Sim1Insert == true) { Sim1Ready = iTelephony.isRadioOnGemini(Phone.GEMINI_SIM_1); } mNetworkMode.setEnabled(Sim1Ready); } catch (RemoteException e) { Xlog.e(TAG, "RemoteException happens......"); } }
public KeyHandler(Context context) { mContext = context; mHandler = new Handler(); mSettingsIntent = new Intent(Intent.ACTION_MAIN, null); mSettingsIntent.setAction(Settings.ACTION_SETTINGS); mSettingsIntent.addFlags( Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED); mAutomaticAvailable = context .getResources() .getBoolean(com.android.internal.R.bool.config_automatic_brightness_available); try { if (Settings.Secure.getInt(mContext.getContentResolver(), SETTING_TOUCHPAD_STATUS) == 0) { mTouchpadEnabled = false; nativeToggleTouchpad(false); } } catch (SettingNotFoundException e) { } IntentFilter filter = new IntentFilter(); filter.addAction(Intent.ACTION_DOCK_EVENT); context.registerReceiver(mDockReceiver, filter); }
/** Returns whether the clings are enabled or should be shown */ private boolean areClingsEnabled() { if (DISABLE_CLINGS) { return false; } // disable clings when running in a test harness if (ActivityManager.isRunningInTestHarness()) return false; // Disable clings for accessibility when explore by touch is enabled final AccessibilityManager a11yManager = (AccessibilityManager) mLauncher.getSystemService(Launcher.ACCESSIBILITY_SERVICE); if (a11yManager.isTouchExplorationEnabled()) { return false; } // Restricted secondary users (child mode) will potentially have very few apps // seeded when they start up for the first time. Clings won't work well with that boolean supportsLimitedUsers = android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2; Account[] accounts = AccountManager.get(mLauncher).getAccounts(); if (supportsLimitedUsers && accounts.length == 0) { UserManager um = (UserManager) mLauncher.getSystemService(Context.USER_SERVICE); Bundle restrictions = um.getUserRestrictions(); if (restrictions.getBoolean(UserManager.DISALLOW_MODIFY_ACCOUNTS, false)) { return false; } } if (Settings.Secure.getInt(mLauncher.getContentResolver(), SKIP_FIRST_USE_HINTS, 0) == 1) { return false; } return true; }
private void createDatabaseFile() { try { fos = this.context.openFileOutput(this.databaseName, Context.MODE_APPEND); JsonObject dataObject = new JsonObject(); dataObject.addProperty( "ANDROID_ID", Settings.Secure.getString(this.context.getContentResolver(), Settings.Secure.ANDROID_ID)); dataObject.addProperty( this.COLUMN_TIME_OFFSET, TimeZone.getDefault().getOffset(System.currentTimeMillis()) / 1000 / 60); try { dataObject.addProperty("FUNF_VERSION", FunfManager.funfManager.getVersion()); } catch (NullPointerException e) { } try { dataObject.addProperty( "APPLICATION_VERSION", FunfManager.funfManager.getApplicationVersion()); } catch (NullPointerException e) { } fos.write((dataObject.toString() + "\n").getBytes()); } catch (IOException e) { e.printStackTrace(); } }
@Override public void onCreate() { super.onCreate(); mLocationFinder = PlatformSpecificImplementationFactory.getLastLocationFinder(this, this); Location location = mLocationFinder.getLastBestLocation(MAX_DISTANCE_LIMIT, MAX_TIME_LIMIT); if (location != null) { onLocationChanged(location); } String provider = Settings.Secure.getString(getContentResolver(), Settings.Secure.LOCATION_PROVIDERS_ALLOWED); if (!"".equals(provider)) { LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE); final boolean gpsEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER); final boolean networkEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER); mNoProviderEnabled = !gpsEnabled && !networkEnabled; } // TODO provide own interface for notifying // that no providers are available if (mNoProviderEnabled) { for (LocationListener listener : mListeners) { listener.onProviderDisabled(null); } } }