PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement new vibrate for calls in Settings.

Browse Source 
Test: built and tested on device
Change-Id: Ia6ca7eb54472d44a9934d7f125a9f71e42c616a3
This commit is contained in:
Yiwen Chen
2020-01-27 17:02:25 -08:00
parent f160cbed83
commit 4b4c6c2c7b
9 changed files with 495 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
src/com/android/settings/notification/VibrateWhenRingPreferenceController.java
View File

@@ -1,144 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.notification;
import static android.provider.Settings.System.VIBRATE_WHEN_RINGING;
import android.content.ContentResolver;
import android.content.Context;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.provider.DeviceConfig;
import android.provider.Settings;
import android.text.TextUtils;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.Utils;
import com.android.settings.core.TogglePreferenceController;
import com.android.settingslib.core.lifecycle.LifecycleObserver;
import com.android.settingslib.core.lifecycle.events.OnPause;
import com.android.settingslib.core.lifecycle.events.OnResume;
public class VibrateWhenRingPreferenceController extends TogglePreferenceController
implements LifecycleObserver, OnResume, OnPause {
/** Flag for whether or not to apply ramping ringer on incoming phone calls. */
private static final String RAMPING_RINGER_ENABLED = "ramping_ringer_enabled";
private static final String KEY_VIBRATE_WHEN_RINGING = "vibrate_when_ringing";
private final int DEFAULT_VALUE = 0;
private final int NOTIFICATION_VIBRATE_WHEN_RINGING = 1;
private SettingObserver mSettingObserver;
public VibrateWhenRingPreferenceController(Context context, String key) {
super(context, key);
}
@Override
public boolean isChecked() {
return Settings.System.getInt(mContext.getContentResolver(),
VIBRATE_WHEN_RINGING, DEFAULT_VALUE) != DEFAULT_VALUE;
}
@Override
public boolean setChecked(boolean isChecked) {
return Settings.System.putInt(mContext.getContentResolver(), VIBRATE_WHEN_RINGING,
isChecked ? NOTIFICATION_VIBRATE_WHEN_RINGING : DEFAULT_VALUE);
}
@Override
@AvailabilityStatus
public int getAvailabilityStatus() {
// If ramping ringer is enabled then this setting will be injected
// with additional options.
return Utils.isVoiceCapable(mContext) && !isRampingRingerEnabled()
? AVAILABLE
: UNSUPPORTED_ON_DEVICE;
}
@Override
public boolean isSliceable() {
return TextUtils.equals(getPreferenceKey(), "vibrate_when_ringing");
}
@Override
public boolean isPublicSlice() {
return true;
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
Preference preference = screen.findPreference(KEY_VIBRATE_WHEN_RINGING);
if (preference != null) {
mSettingObserver = new SettingObserver(preference);
preference.setPersistent(false);
}
}
@Override
public void onResume() {
if (mSettingObserver != null) {
mSettingObserver.register(true /* register */);
}
}
@Override
public void onPause() {
if (mSettingObserver != null) {
mSettingObserver.register(false /* register */);
}
}
private final class SettingObserver extends ContentObserver {
private final Uri VIBRATE_WHEN_RINGING_URI =
Settings.System.getUriFor(VIBRATE_WHEN_RINGING);
private final Preference mPreference;
public SettingObserver(Preference preference) {
super(new Handler());
mPreference = preference;
}
public void register(boolean register) {
final ContentResolver cr = mContext.getContentResolver();
if (register) {
cr.registerContentObserver(VIBRATE_WHEN_RINGING_URI, false, this);
} else {
cr.unregisterContentObserver(this);
}
}
@Override
public void onChange(boolean selfChange, Uri uri) {
super.onChange(selfChange, uri);
if (VIBRATE_WHEN_RINGING_URI.equals(uri)) {
updateState(mPreference);
}
}
}
private boolean isRampingRingerEnabled() {
return DeviceConfig.getBoolean(
DeviceConfig.NAMESPACE_TELEPHONY, RAMPING_RINGER_ENABLED, false);
}
}

66
src/com/android/settings/sound/VibrateForCallsPreferenceController.java Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.sound;
import android.content.Context;
import android.provider.DeviceConfig;
import android.provider.Settings;
import androidx.annotation.VisibleForTesting;
import com.android.settings.R;
import com.android.settings.Utils;
import com.android.settings.core.BasePreferenceController;
/**
* Controller for vibrate for calls settings.
*/
public class VibrateForCallsPreferenceController extends BasePreferenceController {
private static final int ON = 1;
private static final int OFF = 0;
@VisibleForTesting
static final String RAMPING_RINGER_ENABLED = "ramping_ringer_enabled";
public VibrateForCallsPreferenceController(Context context, String preferenceKey) {
super(context, preferenceKey);
}
@Override
@AvailabilityStatus
public int getAvailabilityStatus() {
return Utils.isVoiceCapable(mContext) && !DeviceConfig.getBoolean(
DeviceConfig.NAMESPACE_TELEPHONY, RAMPING_RINGER_ENABLED, false)
? AVAILABLE
: UNSUPPORTED_ON_DEVICE;
}
@Override
public CharSequence getSummary() {
if (Settings.Global.getInt(
mContext.getContentResolver(),
Settings.Global.APPLY_RAMPING_RINGER, OFF) == ON) {
return mContext.getText(R.string.vibrate_when_ringing_option_ramping_ringer);
} else if (Settings.System.getInt(
mContext.getContentResolver(),
Settings.System.VIBRATE_WHEN_RINGING, OFF) == ON) {
return mContext.getText(R.string.vibrate_when_ringing_option_always_vibrate);
} else {
return mContext.getText(R.string.vibrate_when_ringing_option_never_vibrate);
}
}
}

167
src/com/android/settings/sound/VibrateForCallsPreferenceFragment.java Normal file
View File

@@ -0,0 +1,167 @@
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.sound;
import android.app.settings.SettingsEnums;
import android.content.Context;
import android.graphics.drawable.Drawable;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.ArrayMap;
import android.util.Log;
import androidx.annotation.VisibleForTesting;
import com.android.settings.R;
import com.android.settings.widget.RadioButtonPickerFragment;
import com.android.settingslib.widget.CandidateInfo;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* Fragment for changing vibrate for calls options.
*/
public class VibrateForCallsPreferenceFragment extends RadioButtonPickerFragment {
private static final String TAG = "VibrateForCallsPreferenceFragment";
@VisibleForTesting
static final String KEY_NEVER_VIBRATE = "never_vibrate";
@VisibleForTesting
static final String KEY_ALWAYS_VIBRATE = "always_vibrate";
@VisibleForTesting
static final String KEY_RAMPING_RINGER = "ramping_ringer";
private static final int ON = 1;
private static final int OFF = 0;
private final Map<String, VibrateForCallsCandidateInfo> mCandidates;
public VibrateForCallsPreferenceFragment() {
mCandidates = new ArrayMap<>();
}
@Override
public void onAttach(Context context) {
super.onAttach(context);
loadCandidates(context);
}
private void loadCandidates(Context context) {
mCandidates.put(KEY_NEVER_VIBRATE,
new VibrateForCallsCandidateInfo(
KEY_NEVER_VIBRATE, R.string.vibrate_when_ringing_option_never_vibrate));
mCandidates.put(KEY_ALWAYS_VIBRATE,
new VibrateForCallsCandidateInfo(
KEY_ALWAYS_VIBRATE, R.string.vibrate_when_ringing_option_always_vibrate));
mCandidates.put(KEY_RAMPING_RINGER,
new VibrateForCallsCandidateInfo(
KEY_RAMPING_RINGER, R.string.vibrate_when_ringing_option_ramping_ringer));
}
private void updateSettings(VibrateForCallsCandidateInfo candidate) {
final String key = candidate.getKey();
if (TextUtils.equals(key, KEY_ALWAYS_VIBRATE)) {
Settings.System.putInt(
getContext().getContentResolver(), Settings.System.VIBRATE_WHEN_RINGING, ON);
Settings.Global.putInt(
getContext().getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, OFF);
} else if (TextUtils.equals(key, KEY_RAMPING_RINGER)) {
Settings.System.putInt(
getContext().getContentResolver(), Settings.System.VIBRATE_WHEN_RINGING, OFF);
Settings.Global.putInt(
getContext().getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, ON);
} else {
Settings.System.putInt(
getContext().getContentResolver(), Settings.System.VIBRATE_WHEN_RINGING, OFF);
Settings.Global.putInt(
getContext().getContentResolver(), Settings.Global.APPLY_RAMPING_RINGER, OFF);
}
}
@Override
protected List<? extends CandidateInfo> getCandidates() {
final List<VibrateForCallsCandidateInfo> candidates = new ArrayList<>();
candidates.add(mCandidates.get(KEY_NEVER_VIBRATE));
candidates.add(mCandidates.get(KEY_ALWAYS_VIBRATE));
candidates.add(mCandidates.get(KEY_RAMPING_RINGER));
return candidates;
}
@Override
protected String getDefaultKey() {
if (Settings.Global.getInt(
getContext().getContentResolver(),
Settings.Global.APPLY_RAMPING_RINGER, OFF) == ON) {
return KEY_RAMPING_RINGER;
} else if (Settings.System.getInt(
getContext().getContentResolver(),
Settings.System.VIBRATE_WHEN_RINGING, OFF) == ON) {
return KEY_ALWAYS_VIBRATE;
} else {
return KEY_NEVER_VIBRATE;
}
}
@Override
protected boolean setDefaultKey(String key) {
final VibrateForCallsCandidateInfo candidate = mCandidates.get(key);
if (candidate == null) {
Log.e(TAG, "Unknown vibrate for calls candidate (key = " + key + ")!");
return false;
}
updateSettings(candidate);
return true;
}
@Override
protected int getPreferenceScreenResId() {
return R.xml.vibrate_for_calls_settings;
}
@Override
public int getMetricsCategory() {
return SettingsEnums.VIBRATE_FOR_CALLS;
}
@VisibleForTesting
class VibrateForCallsCandidateInfo extends CandidateInfo {
private final String mKey;
private final int mLabelId;
VibrateForCallsCandidateInfo(String key, int labelId) {
super(true /* enabled */);
mKey = key;
mLabelId = labelId;
}
@Override
public CharSequence loadLabel() {
return getContext().getString(mLabelId);
}
@Override
public Drawable loadIcon() {
return null;
}
@Override
public String getKey() {
return mKey;
}
}
}