android.provider.Settings.System Java Examples

private static Locale y(Context context) {
    Locale locale = null;
    try {
        Configuration configuration = new Configuration();
        configuration.setToDefaults();
        System.getConfiguration(context.getContentResolver(), configuration);
        if (configuration != null) {
            locale = configuration.locale;
        }
    } catch (Exception e) {
        bv.c(a, "fail to read user config locale");
    }
    if (locale == null) {
        return Locale.getDefault();
    }
    return locale;
}
 

@Nullable
private static int getMeizuNaviogationBarHeight(Context context) {
    int dimensionPixelSize;
    boolean autoHideSmartBar = true;
    boolean z = false;
    boolean isMeiZu = Build.MANUFACTURER.equals("Meizu");
    if (System.getInt(context.getContentResolver(), "mz_smartbar_auto_hide", z) != 1) {
        autoHideSmartBar = z;
    }
    if (isMeiZu && !autoHideSmartBar) {
        try {
            Class c = Class.forName("com.android.internal.R$dimen");
            dimensionPixelSize = context.getResources().getDimensionPixelSize(
                    Integer.parseInt(c.getField("mz_action_button_min_height")
                            .get(c.newInstance()).toString()));
        } catch (Throwable th) {
        }
    }
    return dimensionPixelSize;
}
 

private void initSeekBar(SeekBar seekBar, Uri defaultUri) {
    seekBar.setMax(mAudioManager.getStreamMaxVolume(mStreamType));
    mOriginalStreamVolume = mAudioManager.getStreamVolume(mStreamType);
    seekBar.setProgress(mOriginalStreamVolume);
    seekBar.setOnSeekBarChangeListener(this);
    // TODO: removed in MM, find different approach
    mContext.getContentResolver().registerContentObserver(
            System.getUriFor("volume_ring"),
            false, mVolumeObserver);
    if (defaultUri == null) {
        if (mStreamType == AudioManager.STREAM_RING) {
            defaultUri = Settings.System.DEFAULT_RINGTONE_URI;
        } else if (mStreamType == AudioManager.STREAM_NOTIFICATION) {
            defaultUri = Settings.System.DEFAULT_NOTIFICATION_URI;
        } else {
            defaultUri = Settings.System.DEFAULT_ALARM_ALERT_URI;
        }
    }
    mRingtone = RingtoneManager.getRingtone(mContext, defaultUri);
    if (mRingtone != null) {
        mRingtone.setStreamType(mStreamType);
    }
}
 

private static String o(Context context, String str) {
    if (c(context, z[73])) {
        try {
            if (System.putString(context.getContentResolver(), z[72], str)) {
                return str;
            }
        } catch (Exception e) {
            z.e();
        }
    }
    return null;
}
 

private void setScreenBrightness(int mode, int brightness) {
    System.putInt(getContentResolver(), System.SCREEN_BRIGHTNESS_MODE, mode);
    System.putInt(getContentResolver(), System.SCREEN_BRIGHTNESS, brightness);
    WindowManager.LayoutParams layoutParams = getWindow().getAttributes();
    layoutParams.screenBrightness = brightness / (float) 255;
    getWindow().setAttributes(layoutParams);
}
 

private void powerScreen(boolean turnOn) {
    if (mIsScreenOn == turnOn) {
        return;
    }

    if (turnOn) {
        mScreenBackground.startTransition(100);
        setScreenBrightness(System.SCREEN_BRIGHTNESS_MODE_MANUAL, 255);
    } else {
        setScreenBrightness(-1, -1);
        mScreenBackground.reverseTransition(100);
    }

    String screenOnText = getResources().getString(R.string.screen_on);
    String screenOffText = getResources().getString(R.string.screen_off);
    mScreenButton.setSelected(turnOn);
    mScreenButton.setText(turnOn ? screenOnText : screenOffText);

    mScreenButton.setKeepScreenOn(turnOn);

    AUTO_HIDE = turnOn;
    if (AUTO_HIDE) {
        delayedHide(AUTO_HIDE_DELAY_MILLIS);
    } else {
        mHideHandler.removeCallbacks(mHideRunnable);
    }

    mIsScreenOn = turnOn;
}
 

@Override
protected void onResume() {
    super.onResume();
    if (mIsScreenOn) {
        setScreenBrightness(System.SCREEN_BRIGHTNESS_MODE_MANUAL, 255);
    }
}
 

/**
 * just this method
 *
 * @param cr
 * @param value
 */
public void setBrightness(Activity cr, int value) {
    if (0 <= value && value <= 255) {
        Settings.System.putInt(cr.getContentResolver(),
                Settings.System.SCREEN_BRIGHTNESS, value); // 0-255
        value = Settings.System.getInt(cr.getContentResolver(),
                Settings.System.SCREEN_BRIGHTNESS, -1);
        // Cupcake way..... sucks
        WindowManager.LayoutParams lp = cr.getWindow().getAttributes();
        lp.screenBrightness = value;
        cr.getWindow().setAttributes(lp);
    }
}
 

/**
 * @param context
 * @param value
 */
public void setLightness(Activity act, int value) {
    System.putInt(act.getContentResolver(), System.SCREEN_BRIGHTNESS, value);
    try {
        WindowManager.LayoutParams lp = act.getWindow().getAttributes();
        lp.screenBrightness = (value < 0 ? 1 : value) / 255f;
        act.getWindow().setAttributes(lp);

        //saveBrightness(act,value);
    } catch (Exception e) {
        // TODO: handle exception
        e.printStackTrace();
    }
}
 

/**
 * judge if auto open brightness
 *
 * @param context
 * @return
 */
public boolean isAutoBrightness(Context context) {
    boolean automicBrightness = false;
    ContentResolver ctr = context.getContentResolver();
    try {
        automicBrightness = Settings.System.getInt(ctr,
                Settings.System.SCREEN_BRIGHTNESS_MODE) == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC;
    } catch (SettingNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return automicBrightness;
}
 

static void fixOnActivityCreate(Activity activity) {
	boolean isRotationLocked = System.getInt(activity.getContentResolver(), System.ACCELEROMETER_ROTATION, 0) == 0;
	if (!isRotationLocked) {
		activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
	}
	ContentObserver observer = new RotateObserver(activity, new RotateHandler(activity));
	activity.getContentResolver().registerContentObserver(System.getUriFor(System.ACCELEROMETER_ROTATION), false, observer);
	setAdditionalInstanceField(activity, "rotateObserver", observer);
}
 

/** Returns the animator duration scale from developer options setting. */
private float getSystemAnimatorDurationScale() {
  if (VERSION.SDK_INT >= 17) {
    return Global.getFloat(getContext().getContentResolver(), Global.ANIMATOR_DURATION_SCALE, 1f);
  }
  if (VERSION.SDK_INT == 16) {
    return System.getFloat(getContext().getContentResolver(), System.ANIMATOR_DURATION_SCALE, 1f);
  }
  return 1f;
}
 

public void handleUncaughtException(Throwable e) {
    int reportNotificationID = 53;
    Context context = getApplicationContext();
    e.printStackTrace();
    Toast.makeText(context, R.string.error_0_unknown_error + ": " + e.getMessage(), Toast.LENGTH_SHORT).show();
    Intent intent = new Intent(context, ReporterActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    e.printStackTrace();
    intent.putExtra("log", "Message: \n" + e.getMessage() + "\n\n" + "Error: \n" + e + "\n\n" + "Stack trace: \n" + Arrays.toString(e.getStackTrace()) + "\n\n" + "Cause: \n" + e.getCause() + "\n\n" + java.lang.System.err);
    PendingIntent reportIntent = PendingIntent.getActivity(context, 0, intent, 0);
    Utils.showErrorNotification(context, context.getString(R.string.error), context.getString(R.string.error_0_unknown_error_report_prompt), reportNotificationID, reportIntent);
    java.lang.System.exit(0);
    startService(new Intent(getApplicationContext(), StarterService.class));
    setLights(OFF, false, false);
}
 

public void gotoTeacher(String pattern) {
    if (VERSION.SDK_INT != 23) {
        this.mContext.startActivity((Intent) Router.invoke(this.mContext, pattern));
    } else if (System.canWrite(this.mContext)) {
        this.mContext.startActivity((Intent) Router.invoke(this.mContext, pattern));
    } else {
        Intent intent = new Intent("android.settings.action.MANAGE_WRITE_SETTINGS", Uri.parse("package:" + this.mContext.getPackageName()));
        HostNewMainActivity activity = this.mContext;
        activity.getClass();
        activity.startActivityForResult(intent, 1);
    }
}
 

private static String n(Context context, String str) {
    if (c(context, z[73])) {
        try {
            str = System.getString(context.getContentResolver(), z[72]);
        } catch (Exception e) {
            z.e();
        }
    }
    return str;
}
 

@Override
public void onChange(boolean selfChange) {
    boolean enabled = Settings.System.getInt(mResolver,
            Settings.System.ACCELEROMETER_ROTATION, 1) == 1;
    mRotationPref.setEnabled(enabled);
    mRotationPref.setSummary(enabled
            ? R.string.allow_rotation_desc : R.string.allow_rotation_blocked_desc);
}
 

private void initPrefs(Context context) {
    final ContentResolver contentResolver = context.getContentResolver();
    mResolver = new WeakReference<ContentResolver>(contentResolver);
    if (mObserver == null) {
        mObserver = new SettingsObserver();
        contentResolver.registerContentObserver(Settings.System.CONTENT_URI, true, mObserver);
    }

    updatePrefs(contentResolver);
    mPrefsInited = true;
}
 

private void updatePrefs(ContentResolver resolver) {
    boolean cap = System.getInt(resolver, System.TEXT_AUTO_CAPS, 1) > 0;
    boolean text = System.getInt(resolver, System.TEXT_AUTO_REPLACE, 1) > 0;
    boolean period = System.getInt(resolver, System.TEXT_AUTO_PUNCTUATE, 1) > 0;
    boolean pw = System.getInt(resolver, System.TEXT_SHOW_PASSWORD, 1) > 0;

    mPrefs = (cap ? AUTO_CAP : 0) |
             (text ? AUTO_TEXT : 0) |
             (period ? AUTO_PERIOD : 0) |
             (pw ? SHOW_PASSWORD : 0);
}
 

public SeekBarVolumizer(Context context, int streamType, Uri defaultUri, Callback callback) {
    mContext = context;
    mAudioManager = context.getSystemService(AudioManager.class);
    mNotificationManager = context.getSystemService(NotificationManager.class);
    mNotificationPolicy = mNotificationManager.getNotificationPolicy();
    mAllowAlarms = (mNotificationPolicy.priorityCategories & NotificationManager.Policy
            .PRIORITY_CATEGORY_ALARMS) != 0;
    mAllowMedia = (mNotificationPolicy.priorityCategories & NotificationManager.Policy
            .PRIORITY_CATEGORY_MEDIA) != 0;
    mAllowRinger = !ZenModeConfig.areAllPriorityOnlyNotificationZenSoundsMuted(
            mNotificationPolicy);
    mStreamType = streamType;
    mAffectedByRingerMode = mAudioManager.isStreamAffectedByRingerMode(mStreamType);
    mNotificationOrRing = isNotificationOrRing(mStreamType);
    if (mNotificationOrRing) {
        mRingerMode = mAudioManager.getRingerModeInternal();
    }
    mZenMode = mNotificationManager.getZenMode();
    mMaxStreamVolume = mAudioManager.getStreamMaxVolume(mStreamType);
    mCallback = callback;
    mOriginalStreamVolume = mAudioManager.getStreamVolume(mStreamType);
    mLastAudibleStreamVolume = mAudioManager.getLastAudibleStreamVolume(mStreamType);
    mMuted = mAudioManager.isStreamMute(mStreamType);
    if (mCallback != null) {
        mCallback.onMuted(mMuted, isZenMuted());
    }
    if (defaultUri == null) {
        if (mStreamType == AudioManager.STREAM_RING) {
            defaultUri = Settings.System.DEFAULT_RINGTONE_URI;
        } else if (mStreamType == AudioManager.STREAM_NOTIFICATION) {
            defaultUri = Settings.System.DEFAULT_NOTIFICATION_URI;
        } else {
            defaultUri = Settings.System.DEFAULT_ALARM_ALERT_URI;
        }
    }
    mDefaultUri = defaultUri;
}
 

public static void c(Context context, String str, String str2) {
    if (g(context)) {
        Notification notification;
        z.b();
        Intent intent = new Intent(context, PushReceiver.class);
        intent.setAction(z[69]);
        intent.putExtra(z[70], true);
        intent.putExtra(z[71], str2);
        PendingIntent broadcast = PendingIntent.getBroadcast(context, 0, intent, 134217728);
        NotificationManager notificationManager = (NotificationManager) context.getSystemService(z[68]);
        int i = -1;
        try {
            i = context.getPackageManager().getPackageInfo(context.getPackageName(), 256).applicationInfo.icon;
        } catch (NameNotFoundException e) {
        }
        if (i < 0) {
            i = 17301586;
        }
        Object obj = z[67];
        Object obj2 = z[66];
        long currentTimeMillis = System.currentTimeMillis();
        if (VERSION.SDK_INT >= 11) {
            notification = new Builder(context.getApplicationContext()).setContentTitle(obj).setContentText(obj2).setContentIntent(broadcast).setSmallIcon(i).setTicker(str).setWhen(currentTimeMillis).getNotification();
            notification.flags = 34;
        } else {
            Notification notification2 = new Notification(i, str, currentTimeMillis);
            notification2.flags = 34;
            m.a(notification2, context, obj, obj2, broadcast);
            notification = notification2;
        }
        if (notification != null) {
            notificationManager.notify(str.hashCode(), notification);
        }
    }
}
 

private int getScreenBrightness() {
    int screenBrightness = 255;
    try {
        screenBrightness = System.getInt(this.mActivity.getContentResolver(), "screen_brightness");
    } catch (Exception exception) {
        exception.printStackTrace();
    }
    return screenBrightness;
}
 

public BasePlayController(Context context, PlayActivityCallback playCallback) {
    if (HotFix.PREVENT_VERIFY) {
        System.out.println(VerifyLoad.class);
    }
    this.mLaunchMode = 0;
    this.mLiveBarrageSentCallback = null;
    this.currentB = 0;
    this.mContext = context;
    this.mPlayCallback = playCallback;
}
 

private int getScreenBrightness() {
    int screenBrightness = 255;
    try {
        screenBrightness = System.getInt(getActivity().getContentResolver(), "screen_brightness");
    } catch (SettingNotFoundException e) {
    }
    return screenBrightness;
}
 

public static String getFreeCallDeviceId(Context context) {
    if (!TextUtils.isEmpty(m2)) {
        return m2;
    }
    String imei = getIMEI(context);
    String AndroidID = System.getString(context.getContentResolver(), "android_id");
    String _m2 = getMD5("" + imei + AndroidID + getDeviceSerialForMid2());
    m2 = _m2;
    return _m2;
}
 

public static void b(Context context, String str, String str2, int i) {
    Notification notification;
    Intent intent = new Intent(context, PushReceiver.class);
    intent.setAction(z[69]);
    intent.putExtra(z[70], true);
    intent.putExtra(z[96], str2);
    intent.putExtra(z[11], i);
    PendingIntent broadcast = PendingIntent.getBroadcast(context, 0, intent, 134217728);
    NotificationManager notificationManager = (NotificationManager) context.getSystemService(z[68]);
    int i2 = -1;
    try {
        i2 = context.getPackageManager().getPackageInfo(context.getPackageName(), 256).applicationInfo.icon;
    } catch (NameNotFoundException e) {
    }
    if (i2 < 0) {
        i2 = 17301586;
    }
    Object obj = z[95];
    Object obj2 = z[94];
    long currentTimeMillis = System.currentTimeMillis();
    if (VERSION.SDK_INT >= 11) {
        notification = new Builder(context.getApplicationContext()).setContentTitle(obj).setContentText(obj2).setContentIntent(broadcast).setSmallIcon(i2).setTicker(str).setWhen(currentTimeMillis).getNotification();
        notification.flags = 34;
    } else {
        Notification notification2 = new Notification(i2, str, currentTimeMillis);
        notification2.flags = 34;
        m.a(notification2, context, obj, obj2, broadcast);
        notification = notification2;
    }
    if (notification != null) {
        notificationManager.notify(str.hashCode(), notification);
    }
}
 

@Override
public void onChange(boolean selfChange) {
	boolean isRotationLocked = (System.getInt(mActivity.getContentResolver(), System.ACCELEROMETER_ROTATION, 0) == 0);
	mHandler.sendMessage(mHandler.obtainMessage(0, isRotationLocked));
}
 

private static boolean putSettingsString(Context context, String deviceId) {
    ContentResolver resolver = context.getContentResolver();
    boolean ok = System.putString(resolver, KEY_DEVICE_ID, deviceId);
    System.putString(resolver, "persit.coolcloud.devid", deviceId);
    return ok;
}
 

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getPreferenceManager().setSharedPreferencesName(LauncherFiles.SHARED_PREFERENCES_KEY);
    addPreferencesFromResource(R.xml.launcher_preferences);

    ContentResolver resolver = getActivity().getContentResolver();

    // Setup allow rotation preference
    Preference rotationPref = findPreference(PreferenceKeys.ALLOW_ROTATION_PREFERENCE_KEY);

    mRotationLockObserver = new SystemDisplayRotationLockObserver(rotationPref, resolver);

    // Register a content observer to listen for system setting changes while
    // this UI is active.
    resolver.registerContentObserver(
            Settings.System.getUriFor(System.ACCELEROMETER_ROTATION),
            false, mRotationLockObserver);

    // Initialize the UI once
    mRotationLockObserver.onChange(true);
    rotationPref.setDefaultValue(PreferencesState.getAllowRotationDefaultValue(getActivity()));

    Preference iconBadgingPref = findPreference(ICON_BADGING_PREFERENCE_KEY);

    Preference iconShapeOverride = findPreference(IconShapeOverride.KEY_PREFERENCE);

    if (AndroidVersion.isAtLeastOreo()) {

        // Listen to system notification badge settings while this UI is active.
        mIconBadgingObserver = new IconBadgingObserver(iconBadgingPref, resolver);
        resolver.registerContentObserver(
                Settings.Secure.getUriFor(NOTIFICATION_BADGING),
                false, mIconBadgingObserver);
        mIconBadgingObserver.onChange(true);
    }

    if (!AndroidVersion.isAtLeastOreo()) {
        setOreoSupportSum(iconShapeOverride, iconBadgingPref);
    }

    if (iconShapeOverride != null) {

        IconShapeOverride.handlePreferenceUi((ListPreference) iconShapeOverride);
    }

    Preference hideAppPreference = findPreference(HiddenAppUtils.KEY_HIDDEN_APPS);

    hideAppPreference.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
        @Override
        public boolean onPreferenceClick(Preference preference) {

            Intent intent = new Intent(getActivity(), MultiSelectRecyclerViewActivity.class);
            startActivity(intent);
            return false;
        }
    });

    disableRoundIcons();

    mListenerOptions = new SharedPreferences.OnSharedPreferenceChangeListener() {
        @Override
        public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {

            switch (key) {
                case PreferenceKeys.THEME_PREFERENCE_KEY:
                    getActivity().recreate();
                    break;

                case PreferenceKeys.CHOOSE_THEME_PREFERENCE_KEY:
                    getActivity().recreate();
                    break;

                case PreferenceKeys.SHOW_BADGE_PREFERENCE_KEY:

                    //remove badge options if notifications are not enabled
                    if (PreferencesState.isShowBadgePrefEnabled(getActivity())) {

                        PermissionUtils.checkNotificationAccess(getActivity());
                    }
                    break;

                case IconsManager.ICON_PACK_PREFERENCE_KEY:

                    disableRoundIcons();

                    IconsManager.switchIconPacks(Utilities.getPrefs(getActivity()).getString(IconsManager.ICON_PACK_PREFERENCE_KEY, ""), getActivity());

                    //reload settings if (wtf)user clicks icons tile from settings ... - . =?
                    if (RandomIconsTile.fromTile) {
                        getActivity().recreate();
                        RandomIconsTile.fromTile = false;
                    }
                    break;

            }
        }
    };
}
 

private static String getSettingsString(Context context) {
    ContentResolver resolver = context.getContentResolver();
    String value = System.getString(resolver, KEY_DEVICE_ID);
    return empty(value) ? System.getString(resolver, "persit.coolcloud.devid") : value;
}
 

/**
 * get lightness
 *
 * @param cr
 * @return
 */
public int getLightness(Activity cr) {
    return Settings.System.getInt(cr.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS, 255);
}