forked from jens/Automation
570 lines
15 KiB
Java
570 lines
15 KiB
Java
package com.jens.automation2;
|
|
|
|
import android.content.ContentValues;
|
|
import android.content.Context;
|
|
import android.media.AudioManager;
|
|
import android.media.RingtoneManager;
|
|
import android.net.Uri;
|
|
import android.provider.MediaStore;
|
|
import android.util.Log;
|
|
import android.widget.Toast;
|
|
|
|
import com.jens.automation2.Action.Action_Enum;
|
|
|
|
import java.io.File;
|
|
import java.util.ArrayList;
|
|
|
|
public class Profile implements Comparable<Profile>
|
|
{
|
|
protected static ArrayList<Profile> profileCollection = new ArrayList<Profile>();
|
|
|
|
protected String name;
|
|
protected String oldName;
|
|
|
|
protected boolean changeSoundMode;
|
|
protected int soundMode;
|
|
|
|
protected boolean changeDndMode;
|
|
protected int dndMode;
|
|
|
|
boolean changeVolumeMusicVideoGameMedia;
|
|
protected int volumeMusic;
|
|
|
|
protected boolean changeVolumeNotifications;
|
|
protected int volumeNotifications;
|
|
|
|
protected boolean changeVolumeAlarms;
|
|
protected int volumeAlarms;
|
|
|
|
protected boolean changeIncomingCallsRingtone;
|
|
protected File incomingCallsRingtone;
|
|
|
|
protected boolean changeVibrateWhenRinging;
|
|
protected boolean vibrateWhenRinging;
|
|
|
|
protected boolean changeNotificationRingtone;
|
|
protected File notificationRingtone;
|
|
|
|
protected boolean changeAudibleSelection;
|
|
protected boolean audibleSelection;
|
|
|
|
protected boolean changeScreenLockUnlockSound;
|
|
boolean screenLockUnlockSound;
|
|
|
|
protected boolean changeHapticFeedback;
|
|
protected boolean hapticFeedback;
|
|
|
|
|
|
public void setName(String name)
|
|
{
|
|
this.oldName = this.name;
|
|
this.name = name;
|
|
}
|
|
|
|
public String getName()
|
|
{
|
|
return name;
|
|
}
|
|
|
|
public void setChangeSoundMode(boolean changeSoundMode)
|
|
{
|
|
this.changeSoundMode = changeSoundMode;
|
|
}
|
|
public boolean getChangeSoundMode()
|
|
{
|
|
return changeSoundMode;
|
|
}
|
|
|
|
public void setSoundMode(int soundMode)
|
|
{
|
|
this.soundMode = soundMode;
|
|
}
|
|
public int getSoundMode()
|
|
{
|
|
return soundMode;
|
|
}
|
|
|
|
public boolean getChangeDndMode()
|
|
{
|
|
return changeDndMode;
|
|
}
|
|
|
|
public void setChangeDndMode(boolean changeDndMode)
|
|
{
|
|
this.changeDndMode = changeDndMode;
|
|
}
|
|
|
|
public int getDndMode()
|
|
{
|
|
return dndMode;
|
|
}
|
|
|
|
public void setDndMode(int dndMode)
|
|
{
|
|
this.dndMode = dndMode;
|
|
}
|
|
|
|
public void setChangeVolumeMusicVideoGameMedia(boolean changeVolumeMusicVideoGameMedia)
|
|
{
|
|
this.changeVolumeMusicVideoGameMedia = changeVolumeMusicVideoGameMedia;
|
|
}
|
|
public boolean getChangeVolumeMusicVideoGameMedia()
|
|
{
|
|
return changeVolumeMusicVideoGameMedia;
|
|
}
|
|
|
|
public void setVolumeMusic(int volumeMusic)
|
|
{
|
|
this.volumeMusic = volumeMusic;
|
|
}
|
|
public int getVolumeMusic()
|
|
{
|
|
return volumeMusic;
|
|
}
|
|
|
|
public void setChangeVolumeNotifications(boolean changeVolumeRingtoneNotifications)
|
|
{
|
|
this.changeVolumeNotifications = changeVolumeRingtoneNotifications;
|
|
}
|
|
public boolean getChangeVolumeNotifications()
|
|
{
|
|
return changeVolumeNotifications;
|
|
}
|
|
|
|
public void setVolumeNotifications(int volumeNotifications)
|
|
{
|
|
this.volumeNotifications = volumeNotifications;
|
|
}
|
|
public int getVolumeNotifications()
|
|
{
|
|
return volumeNotifications;
|
|
}
|
|
|
|
public void setChangeVolumeAlarms(boolean changeVolumeAlarms)
|
|
{
|
|
this.changeVolumeAlarms = changeVolumeAlarms;
|
|
}
|
|
public boolean getChangeVolumeAlarms()
|
|
{
|
|
return changeVolumeAlarms;
|
|
}
|
|
|
|
public void setVolumeAlarms(int volumeAlarms)
|
|
{
|
|
this.volumeAlarms = volumeAlarms;
|
|
}
|
|
public int getVolumeAlarms()
|
|
{
|
|
return volumeAlarms;
|
|
}
|
|
|
|
public void setChangeIncomingCallsRingtone(boolean changeIncomingCallsRingtone)
|
|
{
|
|
this.changeIncomingCallsRingtone = changeIncomingCallsRingtone;
|
|
}
|
|
public boolean getChangeIncomingCallsRingtone()
|
|
{
|
|
return changeIncomingCallsRingtone;
|
|
}
|
|
|
|
public void setIncomingCallsRingtone(File incomingCallsRingtone)
|
|
{
|
|
this.incomingCallsRingtone = incomingCallsRingtone;
|
|
}
|
|
public File getIncomingCallsRingtone()
|
|
{
|
|
return incomingCallsRingtone;
|
|
}
|
|
|
|
public void setChangeVibrateWhenRinging(boolean changeVibrateWhenRinging)
|
|
{
|
|
this.changeVibrateWhenRinging = changeVibrateWhenRinging;
|
|
}
|
|
public boolean getChangeVibrateWhenRinging()
|
|
{
|
|
return changeVibrateWhenRinging;
|
|
}
|
|
|
|
public void setVibrateWhenRinging(boolean vibrateWhenRinging)
|
|
{
|
|
this.vibrateWhenRinging = vibrateWhenRinging;
|
|
}
|
|
public boolean getVibrateWhenRinging()
|
|
{
|
|
return vibrateWhenRinging;
|
|
}
|
|
|
|
public void setChangeNotificationRingtone(boolean changeNotificationRingtone)
|
|
{
|
|
this.changeNotificationRingtone = changeNotificationRingtone;
|
|
}
|
|
public boolean getChangeNotificationRingtone()
|
|
{
|
|
return changeNotificationRingtone;
|
|
}
|
|
|
|
public void setNotificationRingtone(File notificationsRingtone)
|
|
{
|
|
this.notificationRingtone = notificationsRingtone;
|
|
}
|
|
public File getNotificationRingtone()
|
|
{
|
|
return notificationRingtone;
|
|
}
|
|
|
|
public void setChangeAudibleSelection(boolean changeAudibleSelection)
|
|
{
|
|
this.changeAudibleSelection = changeAudibleSelection;
|
|
}
|
|
public boolean getChangeAudibleSelection()
|
|
{
|
|
return changeAudibleSelection;
|
|
}
|
|
|
|
public void setAudibleSelection(boolean audibleSelection)
|
|
{
|
|
this.audibleSelection = audibleSelection;
|
|
}
|
|
public boolean getAudibleSelection()
|
|
{
|
|
return audibleSelection;
|
|
}
|
|
|
|
public void setChangeScreenLockUnlockSound(boolean changeScreenLockUnlockSound)
|
|
{
|
|
this.changeScreenLockUnlockSound = changeScreenLockUnlockSound;
|
|
}
|
|
public boolean getChangeScreenLockUnlockSound()
|
|
{
|
|
return changeScreenLockUnlockSound;
|
|
}
|
|
|
|
public void setScreenLockUnlockSound(boolean screenLockUnlockSound)
|
|
{
|
|
this.screenLockUnlockSound = screenLockUnlockSound;
|
|
}
|
|
public boolean getScreenLockUnlockSound()
|
|
{
|
|
return screenLockUnlockSound;
|
|
}
|
|
|
|
public void setChangeHapticFeedback(boolean changeHapticFeedback)
|
|
{
|
|
this.changeHapticFeedback = changeHapticFeedback;
|
|
}
|
|
public boolean getChangeHapticFeedback()
|
|
{
|
|
return changeHapticFeedback;
|
|
}
|
|
|
|
public void setHapticFeedback(boolean hapticFeedback)
|
|
{
|
|
this.hapticFeedback = hapticFeedback;
|
|
}
|
|
public boolean getHapticFeedback()
|
|
{
|
|
return hapticFeedback;
|
|
}
|
|
|
|
public static ArrayList<Profile> getProfileCollection()
|
|
{
|
|
return profileCollection;
|
|
}
|
|
public static ArrayList<String> getProfileCollectionString()
|
|
{
|
|
ArrayList<String> returnList = new ArrayList<String>();
|
|
for(Profile p : profileCollection)
|
|
returnList.add(p.getName());
|
|
|
|
return returnList;
|
|
}
|
|
|
|
public static Profile getByName(String name)
|
|
{
|
|
for(Profile p : Profile.getProfileCollection())
|
|
if(p.getName().equals(name))
|
|
return p;
|
|
|
|
return null;
|
|
}
|
|
|
|
public boolean delete(AutomationService myAutomationService)
|
|
{
|
|
// TODO Auto-generated method stub
|
|
return false;
|
|
}
|
|
|
|
private boolean applyRingTone(File ringtoneFile, int ringtoneType, Context context)
|
|
{
|
|
Miscellaneous.logEvent("i", "Profile", "Request to set ringtone to " + ringtoneFile.getAbsolutePath(), 3);
|
|
|
|
if(!ringtoneFile.exists() | !ringtoneFile.canRead())
|
|
{
|
|
String message = "Ringtone file does not exist or cannot read it: " + ringtoneFile.getAbsolutePath();
|
|
Miscellaneous.logEvent("i", "Profile", message, 3);
|
|
Toast.makeText(context, message, Toast.LENGTH_SHORT).show();
|
|
return false;
|
|
}
|
|
|
|
ContentValues values = new ContentValues();
|
|
values.put(MediaStore.MediaColumns.DATA, ringtoneFile.getAbsolutePath());
|
|
// values.put(MediaStore.MediaColumns.TITLE, context.getResources().getString(R.string.app_name) + " ringtone");
|
|
// values.put(MediaStore.MediaColumns.TITLE, ringtoneFile.getName().replace(".mp3", "").replace(".", ""));
|
|
values.put(MediaStore.MediaColumns.TITLE, ringtoneFile.getName());
|
|
// values.put(MediaStore.MediaColumns.MIME_TYPE, "audio/*");
|
|
values.put(MediaStore.MediaColumns.MIME_TYPE, "audio/mp3");
|
|
values.put(MediaStore.MediaColumns.SIZE, ringtoneFile.length());
|
|
// values.put(MediaStore.Audio.Media.ARTIST, R.string.app_name);
|
|
values.put(MediaStore.Audio.Media.IS_RINGTONE, ringtoneType == RingtoneManager.TYPE_RINGTONE);
|
|
values.put(MediaStore.Audio.Media.IS_NOTIFICATION, ringtoneType == RingtoneManager.TYPE_NOTIFICATION);
|
|
values.put(MediaStore.Audio.Media.IS_ALARM, false);
|
|
values.put(MediaStore.Audio.Media.IS_MUSIC, false);
|
|
|
|
Uri existingRingTone = MediaStore.Audio.Media.getContentUriForPath(ringtoneFile.getAbsolutePath());
|
|
if(existingRingTone != null)
|
|
context.getContentResolver().delete(existingRingTone, MediaStore.MediaColumns.DATA + "=\"" + ringtoneFile.getAbsolutePath() + "\"", null);
|
|
Uri newRingTone = context.getContentResolver().insert(existingRingTone, values);
|
|
|
|
try
|
|
{
|
|
RingtoneManager.setActualDefaultRingtoneUri(context, ringtoneType, newRingTone);
|
|
Miscellaneous.logEvent("i", "Profile", "Ringtone set to: " + newRingTone.toString(), 1);
|
|
// Ringtone tone = RingtoneManager.getRingtone(context, RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE));
|
|
// tone.play();
|
|
return true;
|
|
}
|
|
catch (Throwable t)
|
|
{
|
|
String message = "Error setting ringtone: " + Log.getStackTraceString(t);
|
|
Miscellaneous.logEvent("e", "Profile", message, 1);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public boolean create(Context context, boolean writeToFile)
|
|
{
|
|
for(Profile profile : Profile.profileCollection)
|
|
{
|
|
if (profile.getName().equals(this.getName()))
|
|
{
|
|
Toast.makeText(context, context.getResources().getString(R.string.anotherProfileByThatName), Toast.LENGTH_LONG).show();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if(plausibilityCheck())
|
|
{
|
|
// add to collection
|
|
Profile.getProfileCollection().add(this);
|
|
|
|
// write to file
|
|
if(writeToFile)
|
|
return XmlFileInterface.writeFile();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public boolean change(Context context)
|
|
{
|
|
if(this.oldName != null && !this.oldName.equals(this.name))
|
|
{
|
|
//Name has changed. We need to look for rules that reference it by its name and update those references
|
|
|
|
// Check if the name is still available
|
|
int counter = 0; // this method should only be a temporary workaround, directly editing the referenced object may cause problems until reloading the config file
|
|
for(Profile profile : Profile.profileCollection)
|
|
{
|
|
if (profile.getName().equals(this.getName()))
|
|
{
|
|
counter++;
|
|
}
|
|
}
|
|
|
|
if(counter > 1)
|
|
{
|
|
Toast.makeText(context, context.getResources().getString(R.string.anotherProfileByThatName), Toast.LENGTH_LONG).show();
|
|
return false;
|
|
}
|
|
|
|
// Check if rules reference this profile
|
|
ArrayList<Rule> rulesThatReferenceMe = Rule.findRuleCandidatesByProfile(this);
|
|
if(rulesThatReferenceMe.size() > 0)
|
|
{
|
|
for(Rule oneRule : rulesThatReferenceMe)
|
|
{
|
|
for(Action oneAction : oneRule.getActionSet())
|
|
{
|
|
if(oneAction.getAction() == Action_Enum.changeSoundProfile)
|
|
{
|
|
oneAction.setParameter2(this.name);
|
|
// We don't need to save the file. This will happen anyway in PointOfInterest.writePoisToFile() below.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(plausibilityCheck())
|
|
{
|
|
// write to file
|
|
if(XmlFileInterface.writeFile())
|
|
{
|
|
AutomationService service = AutomationService.getInstance();
|
|
if(service != null)
|
|
service.applySettingsAndRules();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public boolean delete()
|
|
{
|
|
for(int i = 0; i< Profile.getProfileCollection().size(); i++)
|
|
{
|
|
if(Profile.getProfileCollection().get(i).getName().equals(this.getName()))
|
|
{
|
|
Profile.getProfileCollection().remove(0);
|
|
|
|
// write to file
|
|
return XmlFileInterface.writeFile();
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private boolean plausibilityCheck()
|
|
{
|
|
if(this.getName().equals("null"))
|
|
{
|
|
// Invalid name
|
|
String text = Miscellaneous.getAnyContext().getResources().getString(R.string.invalidProfileName);
|
|
Miscellaneous.logEvent("w", "Profile", text, 2);
|
|
Toast.makeText(Miscellaneous.getAnyContext(), text, Toast.LENGTH_LONG).show();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public int compareTo(Profile another)
|
|
{
|
|
return this.getName().compareTo(another.getName());
|
|
}
|
|
|
|
public void activate(Context context)
|
|
{
|
|
Miscellaneous.logEvent("i", "Profile " + this.getName(), String.format(context.getResources().getString(R.string.profileActivate), this.getName()), 3);
|
|
|
|
AutomationService.getInstance().checkLockSoundChangesTimeElapsed();
|
|
|
|
if(AutomationService.getInstance().getLockSoundChangesEnd() == null)
|
|
{
|
|
try
|
|
{
|
|
AudioManager am = (AudioManager) Miscellaneous.getAnyContext().getSystemService(Context.AUDIO_SERVICE);
|
|
|
|
if(changeSoundMode)
|
|
Actions.setSound(context, soundMode);
|
|
|
|
if(changeDndMode)
|
|
Actions.setDND(context, dndMode);
|
|
|
|
if(changeVolumeMusicVideoGameMedia)
|
|
am.setStreamVolume(AudioManager.STREAM_MUSIC, volumeMusic, AudioManager.FLAG_PLAY_SOUND);
|
|
|
|
if(changeVolumeNotifications)
|
|
am.setStreamVolume(AudioManager.STREAM_NOTIFICATION, volumeNotifications, AudioManager.FLAG_PLAY_SOUND);
|
|
|
|
if(changeVolumeAlarms)
|
|
am.setStreamVolume(AudioManager.STREAM_ALARM, volumeAlarms, AudioManager.FLAG_PLAY_SOUND);
|
|
|
|
if(changeIncomingCallsRingtone)
|
|
if(incomingCallsRingtone != null)
|
|
applyRingTone(incomingCallsRingtone, RingtoneManager.TYPE_RINGTONE, context);
|
|
|
|
if(changeVibrateWhenRinging)
|
|
if(vibrateWhenRinging)
|
|
am.setVibrateSetting(AudioManager.VIBRATE_TYPE_RINGER, AudioManager.VIBRATE_SETTING_ON);
|
|
else
|
|
am.setVibrateSetting(AudioManager.VIBRATE_TYPE_RINGER, AudioManager.VIBRATE_SETTING_OFF);
|
|
|
|
if(changeNotificationRingtone)
|
|
if(notificationRingtone != null)
|
|
applyRingTone(notificationRingtone, RingtoneManager.TYPE_NOTIFICATION, context);
|
|
|
|
if(changeScreenLockUnlockSound)
|
|
{
|
|
android.provider.Settings.System.putInt(context.getContentResolver(), "lockscreen_sounds_enabled" , screenLockUnlockSound ? 1 : 0);
|
|
}
|
|
|
|
if(changeAudibleSelection)
|
|
{
|
|
if(audibleSelection)
|
|
android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.SOUND_EFFECTS_ENABLED, 1); // enable
|
|
else
|
|
android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.SOUND_EFFECTS_ENABLED, 0); // dissable
|
|
}
|
|
|
|
if(changeHapticFeedback)
|
|
{
|
|
if(hapticFeedback)
|
|
android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.HAPTIC_FEEDBACK_ENABLED, 1); // enable
|
|
else
|
|
android.provider.Settings.System.putInt(context.getContentResolver(), android.provider.Settings.System.HAPTIC_FEEDBACK_ENABLED, 0); // disable
|
|
}
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
Miscellaneous.logEvent("e", "Profile " + this.getName(), context.getResources().getString(R.string.errorActivatingProfile) + " " + Log.getStackTraceString(e), 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Miscellaneous.logEvent("i", "Profile " + this.getName(), context.getResources().getString(R.string.noProfileChangeSoundLocked), 3);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String toString()
|
|
{
|
|
return this.getName();
|
|
}
|
|
|
|
public String toStringLong()
|
|
{
|
|
return "no implemented, yet";
|
|
}
|
|
|
|
public static boolean createDummyProfile(Context context, String tagContent)
|
|
{
|
|
Profile newProfile = new Profile();
|
|
|
|
newProfile.setName(tagContent);
|
|
newProfile.setChangeSoundMode(true);
|
|
|
|
if(tagContent.equals("silent"))
|
|
newProfile.setSoundMode(AudioManager.RINGER_MODE_SILENT);
|
|
else if(tagContent.equals("vibrate"))
|
|
newProfile.setSoundMode(AudioManager.RINGER_MODE_VIBRATE);
|
|
else if(tagContent.equals("normal"))
|
|
newProfile.setSoundMode(AudioManager.RINGER_MODE_NORMAL);
|
|
else
|
|
return false;
|
|
|
|
return newProfile.create(context, false);
|
|
}
|
|
|
|
public String getOldName()
|
|
{
|
|
return this.oldName;
|
|
}
|
|
|
|
}
|