1366 lines
44 KiB
Java
Executable File
1366 lines
44 KiB
Java
Executable File
/*
|
|
* Copyright (C) 2015 The CyanogenMod 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 cyanogenmod.app;
|
|
|
|
import android.content.Context;
|
|
import android.media.AudioManager;
|
|
import android.os.Parcel;
|
|
import android.os.ParcelUuid;
|
|
import android.os.Parcelable;
|
|
import android.os.UserHandle;
|
|
import android.provider.Settings;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
|
|
import com.android.internal.policy.IKeyguardService;
|
|
import cyanogenmod.os.Build;
|
|
import cyanogenmod.profiles.AirplaneModeSettings;
|
|
import cyanogenmod.profiles.BrightnessSettings;
|
|
import cyanogenmod.profiles.ConnectionSettings;
|
|
import cyanogenmod.profiles.LockSettings;
|
|
import cyanogenmod.profiles.RingModeSettings;
|
|
import cyanogenmod.profiles.StreamSettings;
|
|
|
|
import cyanogenmod.os.Concierge;
|
|
import cyanogenmod.os.Concierge.ParcelInfo;
|
|
|
|
import org.xmlpull.v1.XmlPullParser;
|
|
import org.xmlpull.v1.XmlPullParserException;
|
|
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.UUID;
|
|
|
|
/**
|
|
* A class that represents a device profile.
|
|
*
|
|
* A {@link Profile} can serve a multitude of purposes, allowing the creator(user)
|
|
* to set overrides for streams, triggers, screen lock, brightness, various other
|
|
* settings.
|
|
*/
|
|
public final class Profile implements Parcelable, Comparable {
|
|
|
|
private String mName;
|
|
|
|
private int mNameResId;
|
|
|
|
private UUID mUuid;
|
|
|
|
private ArrayList<UUID> mSecondaryUuids = new ArrayList<UUID>();
|
|
|
|
private Map<UUID, ProfileGroup> profileGroups = new HashMap<UUID, ProfileGroup>();
|
|
|
|
private ProfileGroup mDefaultGroup;
|
|
|
|
private boolean mStatusBarIndicator = false;
|
|
|
|
private boolean mDirty;
|
|
|
|
private static final String TAG = "Profile";
|
|
|
|
private int mProfileType;
|
|
|
|
private Map<Integer, StreamSettings> streams = new HashMap<Integer, StreamSettings>();
|
|
|
|
private Map<String, ProfileTrigger> mTriggers = new HashMap<String, ProfileTrigger>();
|
|
|
|
private Map<Integer, ConnectionSettings> connections = new HashMap<Integer, ConnectionSettings>();
|
|
|
|
private Map<Integer, ConnectionSettings> networkConnectionSubIds = new HashMap<>();
|
|
|
|
private RingModeSettings mRingMode = new RingModeSettings();
|
|
|
|
private AirplaneModeSettings mAirplaneMode = new AirplaneModeSettings();
|
|
|
|
private BrightnessSettings mBrightness = new BrightnessSettings();
|
|
|
|
private LockSettings mScreenLockMode = new LockSettings();
|
|
|
|
private int mExpandedDesktopMode = ExpandedDesktopMode.DEFAULT;
|
|
|
|
private int mDozeMode = DozeMode.DEFAULT;
|
|
|
|
private int mNotificationLightMode = NotificationLightMode.DEFAULT;
|
|
|
|
/**
|
|
* Lock modes of a device
|
|
*/
|
|
public static class LockMode {
|
|
/** Represents a default state lock mode (user choice) */
|
|
public static final int DEFAULT = 0;
|
|
/** Represents an insecure state lock mode, where the device has no security screen */
|
|
public static final int INSECURE = 1;
|
|
/** Represents a disabled state lock mode, where the devices lock screen can be removed */
|
|
public static final int DISABLE = 2;
|
|
}
|
|
|
|
/**
|
|
* Expanded desktop modes available on a device
|
|
*/
|
|
public static class ExpandedDesktopMode {
|
|
/** Represents a default state expanded desktop mode (user choice) */
|
|
public static final int DEFAULT = 0;
|
|
/** Represents an enabled expanded desktop mode */
|
|
public static final int ENABLE = 1;
|
|
/** Represents a disabled expanded desktop mode */
|
|
public static final int DISABLE = 2;
|
|
}
|
|
|
|
/**
|
|
* Doze modes available on a device
|
|
*/
|
|
public static class DozeMode {
|
|
/** Represents a default Doze mode (user choice) */
|
|
public static final int DEFAULT = 0;
|
|
/** Represents an enabled Doze mode */
|
|
public static final int ENABLE = 1;
|
|
/** Represents an disabled Doze mode */
|
|
public static final int DISABLE = 2;
|
|
}
|
|
|
|
/**
|
|
* Notification light modes available on a device
|
|
*/
|
|
public static class NotificationLightMode {
|
|
/** Represents a default Notification light mode (user choice) */
|
|
public static final int DEFAULT = 0;
|
|
/** Represents an enabled Notification light mode */
|
|
public static final int ENABLE = 1;
|
|
/** Represents a disabled Notification light mode */
|
|
public static final int DISABLE = 2;
|
|
}
|
|
|
|
/**
|
|
* Available trigger types on the device, usually hardware
|
|
*/
|
|
public static class TriggerType {
|
|
/** Represents a WiFi trigger type */
|
|
public static final int WIFI = 0;
|
|
/** Represents a Bluetooth trigger type */
|
|
public static final int BLUETOOTH = 1;
|
|
}
|
|
|
|
/**
|
|
* Various trigger states associated with a {@link TriggerType}
|
|
*/
|
|
public static class TriggerState {
|
|
/** A {@link TriggerState) for when the {@link TriggerType} connects */
|
|
public static final int ON_CONNECT = 0;
|
|
/** A {@link TriggerState) for when the {@link TriggerType} disconnects */
|
|
public static final int ON_DISCONNECT = 1;
|
|
/** A {@link TriggerState) for when the {@link TriggerType} is disabled */
|
|
public static final int DISABLED = 2;
|
|
/**
|
|
* A {@link TriggerState) for when the {@link TriggerType#BLUETOOTH}
|
|
* connects for A2DP session
|
|
*/
|
|
public static final int ON_A2DP_CONNECT = 3;
|
|
/**
|
|
* A {@link TriggerState) for when the {@link TriggerType#BLUETOOTH}
|
|
* disconnects from A2DP session
|
|
*/
|
|
public static final int ON_A2DP_DISCONNECT = 4;
|
|
}
|
|
|
|
/**
|
|
* A {@link Profile} type
|
|
*/
|
|
public static class Type {
|
|
/** Profile type which represents a toggle {@link Profile} */
|
|
public static final int TOGGLE = 0;
|
|
/** Profile type which represents a conditional {@link Profile} */
|
|
public static final int CONDITIONAL = 1;
|
|
}
|
|
|
|
/**
|
|
* A {@link ProfileTrigger} is a {@link TriggerType} which can be queried from the OS
|
|
*/
|
|
public static class ProfileTrigger implements Parcelable {
|
|
private int mType;
|
|
private String mId;
|
|
private String mName;
|
|
private int mState;
|
|
|
|
|
|
/**
|
|
* Construct a {@link ProfileTrigger} based on its type {@link Profile.TriggerType} and if
|
|
* the trigger should fire on a {@link Profile.TriggerState} change.
|
|
*
|
|
* Example:
|
|
* <pre class="prettyprint">
|
|
* triggerId = trigger.getSSID(); // Use the AP's SSID as identifier
|
|
* triggerName = trigger.getTitle(); // Use the AP's name as the trigger name
|
|
* triggerType = Profile.TriggerType.WIFI; // This is a wifi trigger
|
|
* triggerState = Profile.TriggerState.ON_CONNECT; // On Connect of this, trigger
|
|
*
|
|
* Profile.ProfileTrigger profileTrigger =
|
|
* new Profile.ProfileTrigger(triggerType, triggerId, triggerState, triggerName);
|
|
* </pre>
|
|
*
|
|
* @param type a {@link Profile.TriggerType}
|
|
* @param id an identifier for the ProfileTrigger
|
|
* @param state {@link Profile.TriggerState} depending on the TriggerType
|
|
* @param name an identifying name for the ProfileTrigger
|
|
*/
|
|
public ProfileTrigger(int type, String id, int state, String name) {
|
|
mType = type;
|
|
mId = id;
|
|
mState = state;
|
|
mName = name;
|
|
}
|
|
|
|
private ProfileTrigger(Parcel in) {
|
|
// Read parcelable version via the Concierge
|
|
ParcelInfo parcelInfo = Concierge.receiveParcel(in);
|
|
int parcelableVersion = parcelInfo.getParcelVersion();
|
|
|
|
// Pattern here is that all new members should be added to the end of
|
|
// the writeToParcel method. Then we step through each version, until the latest
|
|
// API release to help unravel this parcel
|
|
if (parcelableVersion >= Build.CM_VERSION_CODES.BOYSENBERRY) {
|
|
mType = in.readInt();
|
|
mId = in.readString();
|
|
mState = in.readInt();
|
|
mName = in.readString();
|
|
}
|
|
|
|
// Complete parcel info for the concierge
|
|
parcelInfo.complete();
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(Parcel dest, int flags) {
|
|
// Tell the concierge to prepare the parcel
|
|
ParcelInfo parcelInfo = Concierge.prepareParcel(dest);
|
|
|
|
dest.writeInt(mType);
|
|
dest.writeString(mId);
|
|
dest.writeInt(mState);
|
|
dest.writeString(mName);
|
|
|
|
// Complete the parcel info for the concierge
|
|
parcelInfo.complete();
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link ProfileTrigger} {@link TriggerType}
|
|
* @return {@link TriggerType}
|
|
*/
|
|
public int getType() {
|
|
return mType;
|
|
}
|
|
|
|
/**
|
|
* Get the name associated with the {@link ProfileTrigger}
|
|
* @return a string name
|
|
*/
|
|
public String getName() {
|
|
return mName;
|
|
}
|
|
|
|
/**
|
|
* Get the id associated with the {@link ProfileTrigger}
|
|
* @return an string identifier
|
|
*/
|
|
public String getId() {
|
|
return mId;
|
|
}
|
|
|
|
/**
|
|
* Get the state associated with the {@link ProfileTrigger}
|
|
* @return an integer indicating the state
|
|
*/
|
|
public int getState() {
|
|
return mState;
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public void getXmlString(StringBuilder builder, Context context) {
|
|
final String itemType = mType == TriggerType.WIFI ? "wifiAP" : "btDevice";
|
|
|
|
builder.append("<");
|
|
builder.append(itemType);
|
|
builder.append(" ");
|
|
builder.append(getIdType(mType));
|
|
builder.append("=\"");
|
|
builder.append(mId);
|
|
builder.append("\" state=\"");
|
|
builder.append(mState);
|
|
builder.append("\" name=\"");
|
|
builder.append(mName);
|
|
builder.append("\"></");
|
|
builder.append(itemType);
|
|
builder.append(">\n");
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static ProfileTrigger fromXml(XmlPullParser xpp, Context context) {
|
|
final String name = xpp.getName();
|
|
final int type;
|
|
|
|
if (name.equals("wifiAP")) {
|
|
type = TriggerType.WIFI;
|
|
} else if (name.equals("btDevice")) {
|
|
type = TriggerType.BLUETOOTH;
|
|
} else {
|
|
return null;
|
|
}
|
|
|
|
String id = xpp.getAttributeValue(null, getIdType(type));
|
|
int state = Integer.valueOf(xpp.getAttributeValue(null, "state"));
|
|
String triggerName = xpp.getAttributeValue(null, "name");
|
|
if (triggerName == null) {
|
|
triggerName = id;
|
|
}
|
|
|
|
return new ProfileTrigger(type, id, state, triggerName);
|
|
}
|
|
|
|
private static String getIdType(int type) {
|
|
return type == TriggerType.WIFI ? "ssid" : "address";
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final Parcelable.Creator<ProfileTrigger> CREATOR
|
|
= new Parcelable.Creator<ProfileTrigger>() {
|
|
public ProfileTrigger createFromParcel(Parcel in) {
|
|
return new ProfileTrigger(in);
|
|
}
|
|
|
|
@Override
|
|
public ProfileTrigger[] newArray(int size) {
|
|
return new ProfileTrigger[size];
|
|
}
|
|
};
|
|
}
|
|
|
|
/** @hide */
|
|
public static final Parcelable.Creator<Profile> CREATOR = new Parcelable.Creator<Profile>() {
|
|
public Profile createFromParcel(Parcel in) {
|
|
return new Profile(in);
|
|
}
|
|
|
|
@Override
|
|
public Profile[] newArray(int size) {
|
|
return new Profile[size];
|
|
}
|
|
};
|
|
|
|
public Profile(String name) {
|
|
this(name, -1, UUID.randomUUID());
|
|
}
|
|
|
|
/** @hide */
|
|
public Profile(String name, int nameResId, UUID uuid) {
|
|
mName = name;
|
|
mNameResId = nameResId;
|
|
mUuid = uuid;
|
|
mProfileType = Type.TOGGLE; //Default to toggle type
|
|
mDirty = false;
|
|
}
|
|
|
|
private Profile(Parcel in) {
|
|
readFromParcel(in);
|
|
}
|
|
|
|
/**
|
|
* Get the {@link TriggerState} for a {@link ProfileTrigger} with a given id
|
|
* @param type {@link TriggerType}
|
|
* @param id string id of {@link ProfileTrigger}
|
|
* @return {@link TriggerState}
|
|
*/
|
|
public int getTriggerState(int type, String id) {
|
|
ProfileTrigger trigger = id != null ? mTriggers.get(id) : null;
|
|
if (trigger != null) {
|
|
return trigger.mState;
|
|
}
|
|
return TriggerState.DISABLED;
|
|
}
|
|
|
|
/**
|
|
* Get all the {@link ProfileTrigger}s for a given {@link TriggerType}
|
|
* @param type {@link TriggerType}
|
|
* @return an array list of {@link ProfileTrigger}s
|
|
*/
|
|
public ArrayList<ProfileTrigger> getTriggersFromType(int type) {
|
|
ArrayList<ProfileTrigger> result = new ArrayList<ProfileTrigger>();
|
|
for (Entry<String, ProfileTrigger> profileTrigger: mTriggers.entrySet()) {
|
|
ProfileTrigger trigger = profileTrigger.getValue();
|
|
if (trigger.getType() == type) {
|
|
result.add(trigger);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Set a custom {@link ProfileTrigger}
|
|
* @hide
|
|
*/
|
|
public void setTrigger(int type, String id, int state, String name) {
|
|
if (id == null
|
|
|| type < TriggerType.WIFI || type > TriggerType.BLUETOOTH
|
|
|| state < TriggerState.ON_CONNECT || state > TriggerState.ON_A2DP_DISCONNECT) {
|
|
return;
|
|
}
|
|
|
|
ProfileTrigger trigger = mTriggers.get(id);
|
|
|
|
if (state == TriggerState.DISABLED) {
|
|
if (trigger != null) {
|
|
mTriggers.remove(id);
|
|
}
|
|
} else if (trigger != null) {
|
|
trigger.mState = state;
|
|
} else {
|
|
mTriggers.put(id, new ProfileTrigger(type, id, state, name));
|
|
}
|
|
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Set a {@link ProfileTrigger} on the {@link Profile}
|
|
* @param trigger a {@link ProfileTrigger}
|
|
*/
|
|
public void setTrigger(ProfileTrigger trigger) {
|
|
setTrigger(trigger.getType(), trigger.getId(), trigger.getState(), trigger.getName());
|
|
}
|
|
|
|
public int compareTo(Object obj) {
|
|
Profile tmp = (Profile) obj;
|
|
if (mName.compareTo(tmp.mName) < 0) {
|
|
return -1;
|
|
} else if (mName.compareTo(tmp.mName) > 0) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Add a {@link ProfileGroup} to the {@link Profile}
|
|
* @param profileGroup
|
|
* @hide
|
|
*/
|
|
public void addProfileGroup(ProfileGroup profileGroup) {
|
|
if (profileGroup == null) {
|
|
return;
|
|
}
|
|
|
|
if (profileGroup.isDefaultGroup()) {
|
|
/* we must not have more than one default group */
|
|
if (mDefaultGroup != null) {
|
|
return;
|
|
}
|
|
mDefaultGroup = profileGroup;
|
|
}
|
|
profileGroups.put(profileGroup.getUuid(), profileGroup);
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Remove a {@link ProfileGroup} with a given {@link UUID}
|
|
* @param uuid
|
|
* @hide
|
|
*/
|
|
public void removeProfileGroup(UUID uuid) {
|
|
if (!profileGroups.get(uuid).isDefaultGroup()) {
|
|
profileGroups.remove(uuid);
|
|
} else {
|
|
Log.e(TAG, "Cannot remove default group: " + uuid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get {@link ProfileGroup}s associated with the {@link Profile}
|
|
* @return {@link ProfileGroup[]}
|
|
* @hide
|
|
*/
|
|
public ProfileGroup[] getProfileGroups() {
|
|
return profileGroups.values().toArray(new ProfileGroup[profileGroups.size()]);
|
|
}
|
|
|
|
/**
|
|
* Get a {@link ProfileGroup} with a given {@link UUID}
|
|
* @param uuid
|
|
* @return a {@link ProfileGroup}
|
|
* @hide
|
|
*/
|
|
public ProfileGroup getProfileGroup(UUID uuid) {
|
|
return profileGroups.get(uuid);
|
|
}
|
|
|
|
/**
|
|
* Get the default {@link ProfileGroup} associated with the {@link Profile}
|
|
* @return the default {@link ProfileGroup}
|
|
* @hide
|
|
*/
|
|
public ProfileGroup getDefaultGroup() {
|
|
return mDefaultGroup;
|
|
}
|
|
|
|
/** @hide */
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
/** @hide */
|
|
@Override
|
|
public void writeToParcel(Parcel dest, int flags) {
|
|
// Tell the concierge to prepare the parcel
|
|
ParcelInfo parcelInfo = Concierge.prepareParcel(dest);
|
|
|
|
// === BOYSENBERRY ===
|
|
if (!TextUtils.isEmpty(mName)) {
|
|
dest.writeInt(1);
|
|
dest.writeString(mName);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
if (mNameResId != 0) {
|
|
dest.writeInt(1);
|
|
dest.writeInt(mNameResId);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
if (mUuid != null) {
|
|
dest.writeInt(1);
|
|
new ParcelUuid(mUuid).writeToParcel(dest, 0);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
if (mSecondaryUuids != null && !mSecondaryUuids.isEmpty()) {
|
|
ArrayList<ParcelUuid> uuids = new ArrayList<ParcelUuid>(mSecondaryUuids.size());
|
|
for (UUID u : mSecondaryUuids) {
|
|
uuids.add(new ParcelUuid(u));
|
|
}
|
|
dest.writeInt(1);
|
|
dest.writeParcelableArray(uuids.toArray(new Parcelable[uuids.size()]), flags);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
dest.writeInt(mStatusBarIndicator ? 1 : 0);
|
|
dest.writeInt(mProfileType);
|
|
dest.writeInt(mDirty ? 1 : 0);
|
|
if (profileGroups != null && !profileGroups.isEmpty()) {
|
|
dest.writeInt(1);
|
|
dest.writeTypedArray(profileGroups.values().toArray(
|
|
new ProfileGroup[0]), flags);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
if (streams != null && !streams.isEmpty()) {
|
|
dest.writeInt(1);
|
|
dest.writeTypedArray(streams.values().toArray(
|
|
new StreamSettings[0]), flags);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
if (connections != null && !connections.isEmpty()) {
|
|
dest.writeInt(1);
|
|
dest.writeTypedArray(connections.values().toArray(
|
|
new ConnectionSettings[0]), flags);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
if (mRingMode != null) {
|
|
dest.writeInt(1);
|
|
mRingMode.writeToParcel(dest, 0);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
if (mAirplaneMode != null) {
|
|
dest.writeInt(1);
|
|
mAirplaneMode.writeToParcel(dest, 0);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
if (mBrightness != null) {
|
|
dest.writeInt(1);
|
|
mBrightness.writeToParcel(dest, 0);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
if (mScreenLockMode != null) {
|
|
dest.writeInt(1);
|
|
mScreenLockMode.writeToParcel(dest, 0);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
dest.writeTypedArray(mTriggers.values().toArray(new ProfileTrigger[0]), flags);
|
|
dest.writeInt(mExpandedDesktopMode);
|
|
dest.writeInt(mDozeMode);
|
|
|
|
// === ELDERBERRY ===
|
|
dest.writeInt(mNotificationLightMode);
|
|
|
|
if (networkConnectionSubIds != null && !networkConnectionSubIds.isEmpty()) {
|
|
dest.writeInt(1);
|
|
dest.writeTypedArray(networkConnectionSubIds.values().toArray(
|
|
new ConnectionSettings[0]), flags);
|
|
} else {
|
|
dest.writeInt(0);
|
|
}
|
|
|
|
// Complete the parcel info for the concierge
|
|
parcelInfo.complete();
|
|
}
|
|
|
|
/** @hide */
|
|
public void readFromParcel(Parcel in) {
|
|
// Read parcelable version via the Concierge
|
|
ParcelInfo parcelInfo = Concierge.receiveParcel(in);
|
|
int parcelableVersion = parcelInfo.getParcelVersion();
|
|
|
|
// Pattern here is that all new members should be added to the end of
|
|
// the writeToParcel method. Then we step through each version, until the latest
|
|
// API release to help unravel this parcel
|
|
if (parcelableVersion >= Build.CM_VERSION_CODES.BOYSENBERRY) {
|
|
if (in.readInt() != 0) {
|
|
mName = in.readString();
|
|
}
|
|
if (in.readInt() != 0) {
|
|
mNameResId = in.readInt();
|
|
}
|
|
if (in.readInt() != 0) {
|
|
mUuid = ParcelUuid.CREATOR.createFromParcel(in).getUuid();
|
|
}
|
|
if (in.readInt() != 0) {
|
|
for (Parcelable parcel : in.readParcelableArray(null)) {
|
|
ParcelUuid u = (ParcelUuid) parcel;
|
|
mSecondaryUuids.add(u.getUuid());
|
|
}
|
|
}
|
|
mStatusBarIndicator = (in.readInt() == 1);
|
|
mProfileType = in.readInt();
|
|
mDirty = (in.readInt() == 1);
|
|
if (in.readInt() != 0) {
|
|
for (ProfileGroup group : in.createTypedArray(ProfileGroup.CREATOR)) {
|
|
profileGroups.put(group.getUuid(), group);
|
|
if (group.isDefaultGroup()) {
|
|
mDefaultGroup = group;
|
|
}
|
|
}
|
|
}
|
|
if (in.readInt() != 0) {
|
|
for (StreamSettings stream : in.createTypedArray(StreamSettings.CREATOR)) {
|
|
streams.put(stream.getStreamId(), stream);
|
|
}
|
|
}
|
|
if (in.readInt() != 0) {
|
|
for (ConnectionSettings connection :
|
|
in.createTypedArray(ConnectionSettings.CREATOR)) {
|
|
connections.put(connection.getConnectionId(), connection);
|
|
}
|
|
}
|
|
if (in.readInt() != 0) {
|
|
mRingMode = RingModeSettings.CREATOR.createFromParcel(in);
|
|
}
|
|
if (in.readInt() != 0) {
|
|
mAirplaneMode = AirplaneModeSettings.CREATOR.createFromParcel(in);
|
|
}
|
|
if (in.readInt() != 0) {
|
|
mBrightness = BrightnessSettings.CREATOR.createFromParcel(in);
|
|
}
|
|
if (in.readInt() != 0) {
|
|
mScreenLockMode = LockSettings.CREATOR.createFromParcel(in);
|
|
}
|
|
for (ProfileTrigger trigger : in.createTypedArray(ProfileTrigger.CREATOR)) {
|
|
mTriggers.put(trigger.mId, trigger);
|
|
}
|
|
mExpandedDesktopMode = in.readInt();
|
|
mDozeMode = in.readInt();
|
|
}
|
|
if (parcelableVersion >= Build.CM_VERSION_CODES.ELDERBERRY) {
|
|
mNotificationLightMode = in.readInt();
|
|
if (in.readInt() != 0) {
|
|
for (ConnectionSettings connection :
|
|
in.createTypedArray(ConnectionSettings.CREATOR)) {
|
|
// elderberry can do msim connections
|
|
networkConnectionSubIds.put(connection.getSubId(), connection);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Complete the parcel info for the concierge
|
|
parcelInfo.complete();
|
|
}
|
|
|
|
/**
|
|
* Get the name associated with the {@link Profile}
|
|
* @return a string name of the profile
|
|
*/
|
|
public String getName() {
|
|
return mName;
|
|
}
|
|
|
|
/**
|
|
* Set a name for the {@link Profile}
|
|
* @param name a string for the {@link Profile}
|
|
*/
|
|
public void setName(String name) {
|
|
mName = name;
|
|
mNameResId = -1;
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link Type} of the {@link Profile}
|
|
* @return
|
|
*/
|
|
public int getProfileType() {
|
|
return mProfileType;
|
|
}
|
|
|
|
/**
|
|
* Set the {@link Type} for the {@link Profile}
|
|
* @param type a type of profile
|
|
*/
|
|
public void setProfileType(int type) {
|
|
mProfileType = type;
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link UUID} associated with the {@link Profile}
|
|
* @return the uuid for the profile
|
|
*/
|
|
public UUID getUuid() {
|
|
if (this.mUuid == null) this.mUuid = UUID.randomUUID();
|
|
return this.mUuid;
|
|
}
|
|
|
|
/**
|
|
* Get the secondary {@link UUID}s for the {@link Profile}
|
|
* @return the secondary uuids for the Profile
|
|
*/
|
|
public UUID[] getSecondaryUuids() {
|
|
return mSecondaryUuids.toArray(new UUID[mSecondaryUuids.size()]);
|
|
}
|
|
|
|
/**
|
|
* Set a list of secondary {@link UUID}s for the {@link Profile}
|
|
* @param uuids
|
|
*/
|
|
public void setSecondaryUuids(List<UUID> uuids) {
|
|
mSecondaryUuids.clear();
|
|
if (uuids != null) {
|
|
mSecondaryUuids.addAll(uuids);
|
|
mDirty = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a secondary {@link UUID} to the {@link Profile}
|
|
* @param uuid
|
|
*/
|
|
public void addSecondaryUuid(UUID uuid) {
|
|
if (uuid != null) {
|
|
mSecondaryUuids.add(uuid);
|
|
mDirty = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public boolean getStatusBarIndicator() {
|
|
return mStatusBarIndicator;
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public void setStatusBarIndicator(boolean newStatusBarIndicator) {
|
|
mStatusBarIndicator = newStatusBarIndicator;
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Check if the given {@link Profile} is a {@link Type#CONDITIONAL}
|
|
* @return true if conditional
|
|
*/
|
|
public boolean isConditionalType() {
|
|
return(mProfileType == Type.CONDITIONAL ? true : false);
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public void setConditionalType() {
|
|
mProfileType = Type.CONDITIONAL;
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link RingModeSettings} for the {@link Profile}
|
|
* @return
|
|
*/
|
|
public RingModeSettings getRingMode() {
|
|
return mRingMode;
|
|
}
|
|
|
|
/**
|
|
* Set the {@link RingModeSettings} for the {@link Profile}
|
|
* @param descriptor
|
|
*/
|
|
public void setRingMode(RingModeSettings descriptor) {
|
|
mRingMode = descriptor;
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link LockSettings} for the {@link Profile}
|
|
* @return
|
|
*/
|
|
public LockSettings getScreenLockMode() {
|
|
return mScreenLockMode;
|
|
}
|
|
|
|
/**
|
|
* Set the {@link LockSettings} for the {@link Profile}
|
|
* @param screenLockMode
|
|
*/
|
|
public void setScreenLockMode(LockSettings screenLockMode) {
|
|
mScreenLockMode = screenLockMode;
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link ExpandedDesktopMode} for the {@link Profile}
|
|
* @return
|
|
*/
|
|
public int getExpandedDesktopMode() {
|
|
return mExpandedDesktopMode;
|
|
}
|
|
|
|
/**
|
|
* Set the {@link ExpandedDesktopMode} for the {@link Profile}
|
|
* @return
|
|
*/
|
|
public void setExpandedDesktopMode(int expandedDesktopMode) {
|
|
if (expandedDesktopMode < ExpandedDesktopMode.DEFAULT
|
|
|| expandedDesktopMode > ExpandedDesktopMode.DISABLE) {
|
|
mExpandedDesktopMode = ExpandedDesktopMode.DEFAULT;
|
|
} else {
|
|
mExpandedDesktopMode = expandedDesktopMode;
|
|
}
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link DozeMode} associated with the {@link Profile}
|
|
* @return
|
|
*/
|
|
public int getDozeMode() {
|
|
return mDozeMode;
|
|
}
|
|
|
|
/**
|
|
* Set the {@link DozeMode} associated with the {@link Profile}
|
|
* @return
|
|
*/
|
|
public void setDozeMode(int dozeMode) {
|
|
if (dozeMode < DozeMode.DEFAULT
|
|
|| dozeMode > DozeMode.DISABLE) {
|
|
mDozeMode = DozeMode.DEFAULT;
|
|
} else {
|
|
mDozeMode = dozeMode;
|
|
}
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link NotificationLightMode} associated with the {@link Profile}
|
|
* @return
|
|
*/
|
|
public int getNotificationLightMode() {
|
|
return mNotificationLightMode;
|
|
}
|
|
|
|
/**
|
|
* Set the {@link NotificationLightMode} associated with the {@link Profile}
|
|
* @return
|
|
*/
|
|
public void setNotificationLightMode(int notificationLightMode) {
|
|
if (notificationLightMode < NotificationLightMode.DEFAULT
|
|
|| notificationLightMode > NotificationLightMode.DISABLE) {
|
|
mNotificationLightMode = NotificationLightMode.DEFAULT;
|
|
} else {
|
|
mNotificationLightMode = notificationLightMode;
|
|
}
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link AirplaneModeSettings} associated with the {@link Profile}
|
|
* @return
|
|
*/
|
|
public AirplaneModeSettings getAirplaneMode() {
|
|
return mAirplaneMode;
|
|
}
|
|
|
|
/**
|
|
* Set the {@link AirplaneModeSettings} associated with the {@link Profile}
|
|
* @param descriptor
|
|
*/
|
|
public void setAirplaneMode(AirplaneModeSettings descriptor) {
|
|
mAirplaneMode = descriptor;
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link BrightnessSettings} associated with the {@link Profile}
|
|
* @return
|
|
*/
|
|
public BrightnessSettings getBrightness() {
|
|
return mBrightness;
|
|
}
|
|
|
|
/**
|
|
* Set the {@link BrightnessSettings} associated with the {@link Profile}
|
|
* @return
|
|
*/
|
|
public void setBrightness(BrightnessSettings descriptor) {
|
|
mBrightness = descriptor;
|
|
mDirty = true;
|
|
}
|
|
|
|
/** @hide */
|
|
public boolean isDirty() {
|
|
if (mDirty) {
|
|
return true;
|
|
}
|
|
for (ProfileGroup group : profileGroups.values()) {
|
|
if (group.isDirty()) {
|
|
return true;
|
|
}
|
|
}
|
|
for (StreamSettings stream : streams.values()) {
|
|
if (stream.isDirty()) {
|
|
return true;
|
|
}
|
|
}
|
|
for (ConnectionSettings conn : connections.values()) {
|
|
if (conn.isDirty()) {
|
|
return true;
|
|
}
|
|
}
|
|
for (ConnectionSettings conn : networkConnectionSubIds.values()) {
|
|
if (conn.isDirty()) {
|
|
return true;
|
|
}
|
|
}
|
|
if (mRingMode.isDirty()) {
|
|
return true;
|
|
}
|
|
if (mAirplaneMode.isDirty()) {
|
|
return true;
|
|
}
|
|
if (mBrightness.isDirty()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** @hide */
|
|
public void getXmlString(StringBuilder builder, Context context) {
|
|
builder.append("<profile ");
|
|
if (mNameResId > 0) {
|
|
builder.append("nameres=\"");
|
|
builder.append(context.getResources().getResourceEntryName(mNameResId));
|
|
} else {
|
|
builder.append("name=\"");
|
|
builder.append(TextUtils.htmlEncode(getName()));
|
|
}
|
|
builder.append("\" uuid=\"");
|
|
builder.append(TextUtils.htmlEncode(getUuid().toString()));
|
|
builder.append("\">\n");
|
|
|
|
builder.append("<uuids>");
|
|
for (UUID u : mSecondaryUuids) {
|
|
builder.append("<uuid>");
|
|
builder.append(TextUtils.htmlEncode(u.toString()));
|
|
builder.append("</uuid>");
|
|
}
|
|
builder.append("</uuids>\n");
|
|
|
|
builder.append("<profiletype>");
|
|
builder.append(getProfileType() == Type.TOGGLE ? "toggle" : "conditional");
|
|
builder.append("</profiletype>\n");
|
|
|
|
builder.append("<statusbar>");
|
|
builder.append(getStatusBarIndicator() ? "yes" : "no");
|
|
builder.append("</statusbar>\n");
|
|
|
|
if (mScreenLockMode != null) {
|
|
builder.append("<screen-lock-mode>");
|
|
mScreenLockMode.writeXmlString(builder, context);
|
|
builder.append("</screen-lock-mode>\n");
|
|
}
|
|
|
|
builder.append("<expanded-desktop-mode>");
|
|
builder.append(mExpandedDesktopMode);
|
|
builder.append("</expanded-desktop-mode>\n");
|
|
|
|
builder.append("<doze-mode>");
|
|
builder.append(mDozeMode);
|
|
builder.append("</doze-mode>\n");
|
|
|
|
builder.append("<notification-light-mode>");
|
|
builder.append(mNotificationLightMode);
|
|
builder.append("</notification-light-mode>\n");
|
|
|
|
mAirplaneMode.getXmlString(builder, context);
|
|
|
|
mBrightness.getXmlString(builder, context);
|
|
|
|
mRingMode.getXmlString(builder, context);
|
|
|
|
for (ProfileGroup pGroup : profileGroups.values()) {
|
|
pGroup.getXmlString(builder, context);
|
|
}
|
|
for (StreamSettings sd : streams.values()) {
|
|
sd.getXmlString(builder, context);
|
|
}
|
|
for (ConnectionSettings cs : connections.values()) {
|
|
cs.getXmlString(builder, context);
|
|
}
|
|
for (ConnectionSettings cs : networkConnectionSubIds.values()) {
|
|
cs.getXmlString(builder, context);
|
|
}
|
|
if (!mTriggers.isEmpty()) {
|
|
builder.append("<triggers>\n");
|
|
for (ProfileTrigger trigger : mTriggers.values()) {
|
|
trigger.getXmlString(builder, context);
|
|
}
|
|
builder.append("</triggers>\n");
|
|
}
|
|
|
|
builder.append("</profile>\n");
|
|
mDirty = false;
|
|
}
|
|
|
|
private static List<UUID> readSecondaryUuidsFromXml(XmlPullParser xpp, Context context)
|
|
throws XmlPullParserException,
|
|
IOException {
|
|
ArrayList<UUID> uuids = new ArrayList<UUID>();
|
|
int event = xpp.next();
|
|
while (event != XmlPullParser.END_TAG || !xpp.getName().equals("uuids")) {
|
|
if (event == XmlPullParser.START_TAG) {
|
|
String name = xpp.getName();
|
|
if (name.equals("uuid")) {
|
|
try {
|
|
uuids.add(UUID.fromString(xpp.nextText()));
|
|
} catch (NullPointerException e) {
|
|
Log.w(TAG, "Null Pointer - invalid UUID");
|
|
} catch (IllegalArgumentException e) {
|
|
Log.w(TAG, "UUID not recognized");
|
|
}
|
|
}
|
|
}
|
|
event = xpp.next();
|
|
}
|
|
return uuids;
|
|
}
|
|
|
|
private static void readTriggersFromXml(XmlPullParser xpp, Context context, Profile profile)
|
|
throws XmlPullParserException, IOException {
|
|
int event = xpp.next();
|
|
while (event != XmlPullParser.END_TAG || !xpp.getName().equals("triggers")) {
|
|
if (event == XmlPullParser.START_TAG) {
|
|
ProfileTrigger trigger = ProfileTrigger.fromXml(xpp, context);
|
|
if (trigger != null) {
|
|
profile.mTriggers.put(trigger.mId, trigger);
|
|
}
|
|
} else if (event == XmlPullParser.END_DOCUMENT) {
|
|
throw new IOException("Premature end of file while parsing triggers");
|
|
}
|
|
event = xpp.next();
|
|
}
|
|
}
|
|
|
|
/** @hide */
|
|
public void validateRingtones(Context context) {
|
|
for (ProfileGroup pg : profileGroups.values()) {
|
|
pg.validateOverrideUris(context);
|
|
}
|
|
}
|
|
|
|
/** @hide */
|
|
public static Profile fromXml(XmlPullParser xpp, Context context)
|
|
throws XmlPullParserException, IOException {
|
|
String value = xpp.getAttributeValue(null, "nameres");
|
|
int profileNameResId = -1;
|
|
String profileName = null;
|
|
|
|
if (value != null) {
|
|
profileNameResId = context.getResources().getIdentifier(value, "string",
|
|
"cyanogenmod.platform");
|
|
if (profileNameResId > 0) {
|
|
profileName = context.getResources().getString(profileNameResId);
|
|
}
|
|
}
|
|
|
|
if (profileName == null) {
|
|
profileName = xpp.getAttributeValue(null, "name");
|
|
}
|
|
|
|
UUID profileUuid = UUID.randomUUID();
|
|
try {
|
|
profileUuid = UUID.fromString(xpp.getAttributeValue(null, "uuid"));
|
|
} catch (NullPointerException e) {
|
|
Log.w(TAG,
|
|
"Null Pointer - UUID not found for "
|
|
+ profileName
|
|
+ ". New UUID generated: "
|
|
+ profileUuid.toString()
|
|
);
|
|
} catch (IllegalArgumentException e) {
|
|
Log.w(TAG,
|
|
"UUID not recognized for "
|
|
+ profileName
|
|
+ ". New UUID generated: "
|
|
+ profileUuid.toString()
|
|
);
|
|
}
|
|
|
|
Profile profile = new Profile(profileName, profileNameResId, profileUuid);
|
|
int event = xpp.next();
|
|
while (event != XmlPullParser.END_TAG) {
|
|
if (event == XmlPullParser.START_TAG) {
|
|
String name = xpp.getName();
|
|
if (name.equals("uuids")) {
|
|
profile.setSecondaryUuids(readSecondaryUuidsFromXml(xpp, context));
|
|
}
|
|
if (name.equals("statusbar")) {
|
|
profile.setStatusBarIndicator(xpp.nextText().equals("yes"));
|
|
}
|
|
if (name.equals("profiletype")) {
|
|
profile.setProfileType(xpp.nextText().equals("toggle")
|
|
? Type.TOGGLE : Type.CONDITIONAL);
|
|
}
|
|
if (name.equals("ringModeDescriptor")) {
|
|
RingModeSettings smd = RingModeSettings.fromXml(xpp, context);
|
|
profile.setRingMode(smd);
|
|
}
|
|
if (name.equals("airplaneModeDescriptor")) {
|
|
AirplaneModeSettings amd = AirplaneModeSettings.fromXml(xpp, context);
|
|
profile.setAirplaneMode(amd);
|
|
}
|
|
if (name.equals("brightnessDescriptor")) {
|
|
BrightnessSettings bd = BrightnessSettings.fromXml(xpp, context);
|
|
profile.setBrightness(bd);
|
|
}
|
|
if (name.equals("screen-lock-mode")) {
|
|
LockSettings lockMode = new LockSettings(Integer.valueOf(xpp.nextText()));
|
|
profile.setScreenLockMode(lockMode);
|
|
}
|
|
if (name.equals("expanded-desktop-mode")) {
|
|
profile.setExpandedDesktopMode(Integer.valueOf(xpp.nextText()));
|
|
}
|
|
if (name.equals("doze-mode")) {
|
|
profile.setDozeMode(Integer.valueOf(xpp.nextText()));
|
|
}
|
|
if (name.equals("notification-light-mode")) {
|
|
profile.setNotificationLightMode(Integer.valueOf(xpp.nextText()));
|
|
}
|
|
if (name.equals("profileGroup")) {
|
|
ProfileGroup pg = ProfileGroup.fromXml(xpp, context);
|
|
profile.addProfileGroup(pg);
|
|
}
|
|
if (name.equals("streamDescriptor")) {
|
|
StreamSettings sd = StreamSettings.fromXml(xpp, context);
|
|
profile.setStreamSettings(sd);
|
|
}
|
|
if (name.equals("connectionDescriptor")) {
|
|
ConnectionSettings cs = ConnectionSettings.fromXml(xpp, context);
|
|
if (Build.CM_VERSION.SDK_INT >= Build.CM_VERSION_CODES.ELDERBERRY
|
|
&& cs.getConnectionId() == ConnectionSettings.PROFILE_CONNECTION_2G3G4G) {
|
|
profile.networkConnectionSubIds.put(cs.getSubId(), cs);
|
|
} else {
|
|
profile.connections.put(cs.getConnectionId(), cs);
|
|
}
|
|
}
|
|
if (name.equals("triggers")) {
|
|
readTriggersFromXml(xpp, context, profile);
|
|
}
|
|
} else if (event == XmlPullParser.END_DOCUMENT) {
|
|
throw new IOException("Premature end of file while parsing profle:" + profileName);
|
|
}
|
|
event = xpp.next();
|
|
}
|
|
|
|
/* we just loaded from XML, so nothing needs saving */
|
|
profile.mDirty = false;
|
|
|
|
return profile;
|
|
}
|
|
|
|
/** @hide */
|
|
public void doSelect(Context context, IKeyguardService keyguardService) {
|
|
// Set stream volumes
|
|
AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
|
|
for (StreamSettings sd : streams.values()) {
|
|
if (sd.isOverride()) {
|
|
am.setStreamVolume(sd.getStreamId(), sd.getValue(), 0);
|
|
}
|
|
}
|
|
// Set connections
|
|
for (ConnectionSettings cs : connections.values()) {
|
|
if (cs.isOverride()) {
|
|
cs.processOverride(context);
|
|
}
|
|
}
|
|
for (ConnectionSettings cs : networkConnectionSubIds.values()) {
|
|
if (cs.isOverride()) {
|
|
cs.processOverride(context);
|
|
}
|
|
}
|
|
|
|
// Set ring mode
|
|
mRingMode.processOverride(context);
|
|
// Set airplane mode
|
|
mAirplaneMode.processOverride(context);
|
|
|
|
// Set brightness
|
|
mBrightness.processOverride(context);
|
|
|
|
if (keyguardService != null) {
|
|
// Set lock screen mode
|
|
mScreenLockMode.processOverride(context, keyguardService);
|
|
} else {
|
|
Log.e(TAG, "cannot process screen lock override without a keyguard service.");
|
|
}
|
|
|
|
// Set expanded desktop
|
|
// if (mExpandedDesktopMode != ExpandedDesktopMode.DEFAULT) {
|
|
// Settings.System.putIntForUser(context.getContentResolver(),
|
|
// Settings.System.EXPANDED_DESKTOP_STATE,
|
|
// mExpandedDesktopMode == ExpandedDesktopMode.ENABLE ? 1 : 0,
|
|
// UserHandle.USER_CURRENT);
|
|
// }
|
|
|
|
// Set doze mode
|
|
if (mDozeMode != DozeMode.DEFAULT) {
|
|
Settings.Secure.putIntForUser(context.getContentResolver(),
|
|
Settings.Secure.DOZE_ENABLED,
|
|
mDozeMode == DozeMode.ENABLE ? 1 : 0,
|
|
UserHandle.USER_CURRENT);
|
|
}
|
|
|
|
// Set notification light mode
|
|
if (mNotificationLightMode != NotificationLightMode.DEFAULT) {
|
|
Settings.System.putIntForUser(context.getContentResolver(),
|
|
Settings.System.NOTIFICATION_LIGHT_PULSE,
|
|
mNotificationLightMode == NotificationLightMode.ENABLE ? 1 : 0,
|
|
UserHandle.USER_CURRENT);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the settings for a stream id in the {@link Profile}
|
|
* @return {@link StreamSettings}
|
|
*/
|
|
public StreamSettings getSettingsForStream(int streamId){
|
|
return streams.get(streamId);
|
|
}
|
|
|
|
/**
|
|
* Set the {@link StreamSettings} for the {@link Profile}
|
|
* @param descriptor
|
|
*/
|
|
public void setStreamSettings(StreamSettings descriptor){
|
|
streams.put(descriptor.getStreamId(), descriptor);
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link StreamSettings} for the {@link Profile}
|
|
* @return {@link Collection<StreamSettings>}
|
|
*/
|
|
public Collection<StreamSettings> getStreamSettings(){
|
|
return streams.values();
|
|
}
|
|
|
|
/**
|
|
* Get the settings for a connection id in the {@link Profile}
|
|
* @return {@link ConnectionSettings}
|
|
*/
|
|
public ConnectionSettings getSettingsForConnection(int connectionId){
|
|
if (connectionId == ConnectionSettings.PROFILE_CONNECTION_2G3G4G) {
|
|
if (networkConnectionSubIds.size() > 1) {
|
|
throw new UnsupportedOperationException("Use getConnectionSettingsWithSubId for MSIM devices!");
|
|
} else {
|
|
return networkConnectionSubIds.values().iterator().next();
|
|
}
|
|
}
|
|
return connections.get(connectionId);
|
|
}
|
|
|
|
/**
|
|
* Get the settings for a {@link ConnectionSettings#PROFILE_CONNECTION_2G3G4G} by sub id.
|
|
*
|
|
* @param subId the sub id to lookup. Can be {@link android.telephony.SubscriptionManager#INVALID_SUBSCRIPTION_ID}
|
|
* @return {@link ConnectionSettings}
|
|
*/
|
|
public ConnectionSettings getConnectionSettingWithSubId(int subId) {
|
|
return networkConnectionSubIds.get(subId);
|
|
}
|
|
|
|
/**
|
|
* Set the {@link ConnectionSettings} for the {@link Profile}
|
|
* @param descriptor
|
|
*/
|
|
public void setConnectionSettings(ConnectionSettings descriptor) {
|
|
if (descriptor.getConnectionId() == ConnectionSettings.PROFILE_CONNECTION_2G3G4G) {
|
|
networkConnectionSubIds.put(descriptor.getSubId(), descriptor);
|
|
} else {
|
|
connections.put(descriptor.getConnectionId(), descriptor);
|
|
}
|
|
mDirty = true;
|
|
}
|
|
|
|
/**
|
|
* Get the {@link ConnectionSettings} for the {@link Profile}
|
|
* @return {@link Collection<ConnectionSettings>}
|
|
*/
|
|
public Collection<ConnectionSettings> getConnectionSettings(){
|
|
List<ConnectionSettings> combinedList = new ArrayList<>();
|
|
combinedList.addAll(connections.values());
|
|
combinedList.addAll(networkConnectionSubIds.values());
|
|
return combinedList;
|
|
}
|
|
}
|