public class VolumeHelper {
private static final int DEFAULT_VALUE_BCT = 9;
private static final int DEFAULT_VALUE_EARBUD = 9;
private static final String EXTRA_HEADSET_STATE = "state";
public static final int HEADSET_STATE_PLUGGED = 1;
public static final int HEADSET_STATE_UNPLUGGED = 0;
private static final int NUM_VALUES_BCT = 10;
private static final int NUM_VALUES_EARBUDS = 19;
private static final FormattingLogger logger = FormattingLoggers.getContextLogger();
private final AudioManager audioManager;
public VolumeHelper(Context paramContext, AudioManager paramAudioManager) {
this.audioManager = paramAudioManager;
}
public static int getHeadsetState(Context paramContext) {
return getHeadsetState(
paramContext.registerReceiver(
null, new IntentFilter("android.intent.action.HEADSET_PLUG")));
}
public static int getHeadsetState(Intent paramIntent) {
if (paramIntent == null) {
logger.d("Defaulting to headset state: 0", new Object[0]);
return 0;
}
int i = paramIntent.getIntExtra("state", 0);
FormattingLogger localFormattingLogger = logger;
Object[] arrayOfObject = new Object[1];
arrayOfObject[0] = Integer.valueOf(i);
localFormattingLogger.d("Determined headset state: %s", arrayOfObject);
return i;
}
public static int getNumVolumeValues(int paramInt) {
if (paramInt == 1) return 19;
return 10;
}
public int readAudioVolume(int paramInt) {
try {
int j = Integer.parseInt(this.audioManager.getParameters("earbuds_volume"));
FormattingLogger localFormattingLogger2 = logger;
Object[] arrayOfObject2 = new Object[1];
arrayOfObject2[0] = Integer.valueOf(j);
localFormattingLogger2.d("Read volume from HAL: %s", arrayOfObject2);
return j;
} catch (NumberFormatException localNumberFormatException) {
if (paramInt != 1) ;
}
for (int i = 9; ; i = 9) {
FormattingLogger localFormattingLogger1 = logger;
Object[] arrayOfObject1 = new Object[1];
arrayOfObject1[0] = Integer.valueOf(i);
localFormattingLogger1.w(
localNumberFormatException,
"Could not read HAL volume, defaulting to: %s",
arrayOfObject1);
return i;
}
}
public void writeAudioVolume(int paramInt1, int paramInt2) {
FormattingLogger localFormattingLogger = logger;
Object[] arrayOfObject = new Object[1];
arrayOfObject[0] = Integer.valueOf(paramInt2);
localFormattingLogger.d("Writing volume to HAL: %s", arrayOfObject);
this.audioManager.setParameters("earbuds_volume=" + paramInt2);
}
}
public class ProtoListFile<T extends MessageNano> {
private static final long TIME_BETWEEN_SAVES_MS = TimeUnit.MINUTES.toMillis(1L);
private static final FormattingLogger logger = FormattingLoggers.getContextLogger();
private final Context context;
private final ScheduledExecutorService executor;
private final ProtoParser<T> parser;
private final String path;
private List<T> saveQueue = new ArrayList();
public ProtoListFile(
Context paramContext,
String paramString,
ScheduledExecutorService paramScheduledExecutorService,
ProtoParser<T> paramProtoParser) {
this.context = paramContext;
this.path = paramString;
this.executor = paramScheduledExecutorService;
this.parser = paramProtoParser;
}
private T readProto(DataInputStream paramDataInputStream) throws IOException {
int i = paramDataInputStream.readInt();
byte[] arrayOfByte = new byte[i];
paramDataInputStream.readFully(arrayOfByte, 0, i);
return this.parser.parse(arrayOfByte);
}
private void writeProto(T paramT, DataOutputStream paramDataOutputStream) throws IOException {
byte[] arrayOfByte = MessageNano.toByteArray(paramT);
paramDataOutputStream.writeInt(arrayOfByte.length);
paramDataOutputStream.write(arrayOfByte, 0, arrayOfByte.length);
}
public void delete() {
Assert.assertNotUiThread();
this.context.deleteFile(this.path);
this.saveQueue.clear();
}
public void flushWrites() {
Assert.assertNotUiThread();
if (!this.saveQueue.isEmpty()) {
FileOutputStream localFileOutputStream = null;
try {
localFileOutputStream = this.context.openFileOutput(this.path, 32768);
DataOutputStream localDataOutputStream =
new DataOutputStream(new BufferedOutputStream(localFileOutputStream));
int i = 0;
int j = this.saveQueue.size();
while (i < j) {
writeProto((MessageNano) this.saveQueue.get(i), localDataOutputStream);
i++;
}
localDataOutputStream.flush();
logger.i("Saved " + this.saveQueue.size() + " proto(s) to disk.", new Object[0]);
this.saveQueue.clear();
if (localFileOutputStream != null) ;
try {
localFileOutputStream.close();
return;
} catch (IOException localIOException4) {
logger.w("Could not close protos file after write.", new Object[] {localIOException4});
return;
}
} catch (IOException localIOException2) {
do {
logger.w("Could not write protos.", new Object[] {localIOException2});
this.saveQueue.clear();
} while (localFileOutputStream == null);
try {
localFileOutputStream.close();
return;
} catch (IOException localIOException3) {
logger.w("Could not close protos file after write.", new Object[] {localIOException3});
return;
}
} finally {
this.saveQueue.clear();
if (localFileOutputStream == null) ;
}
try {
localFileOutputStream.close();
throw localObject;
} catch (IOException localIOException1) {
while (true)
logger.w("Could not close protos file after write.", new Object[] {localIOException1});
}
}
logger.i("No protos to save to disk.", new Object[0]);
}
public long flushedSize() {
Assert.assertNotUiThread();
return this.context.getFileStreamPath(this.path).length();
}
public List<T> read() {
Assert.assertNotUiThread();
FileInputStream localFileInputStream = null;
try {
localFileInputStream = this.context.openFileInput(this.path);
DataInputStream localDataInputStream =
new DataInputStream(new BufferedInputStream(localFileInputStream));
localArrayList = new ArrayList();
int i = 1;
while (i != 0)
try {
localArrayList.add(readProto(localDataInputStream));
} catch (EOFException localEOFException) {
i = 0;
}
logger.i("Read " + localArrayList.size() + " persisted protos.", new Object[0]);
if (localArrayList.isEmpty()) this.context.deleteFile(this.path);
localArrayList.addAll(this.saveQueue);
if (localFileInputStream != null) ;
try {
localFileInputStream.close();
return localArrayList;
} catch (IOException localIOException4) {
logger.w("Could not close file after read.", new Object[] {localIOException4});
return localArrayList;
}
} catch (IOException localIOException2) {
ArrayList localArrayList;
do {
logger.d("Could not read protos from disk.", new Object[] {localIOException2});
this.context.deleteFile(this.path);
localArrayList = new ArrayList(this.saveQueue);
} while (localFileInputStream == null);
try {
localFileInputStream.close();
return localArrayList;
} catch (IOException localIOException3) {
logger.w("Could not close file after read.", new Object[] {localIOException3});
return localArrayList;
}
} finally {
if (localFileInputStream == null) ;
}
try {
localFileInputStream.close();
throw localObject;
} catch (IOException localIOException1) {
while (true) logger.w("Could not close file after read.", new Object[] {localIOException1});
}
}
public void write(T paramT) {
Assert.assertNotUiThread();
if (this.saveQueue.isEmpty())
this.executor.schedule(
new Runnable() {
public void run() {
ProtoListFile.this.flushWrites();
}
},
TIME_BETWEEN_SAVES_MS,
TimeUnit.MILLISECONDS);
this.saveQueue.add(paramT);
}
}