Remove AACRecording and AddAttachment activities

pull/513/head
Alex Baker 6 years ago
parent 3f5f825c22
commit 96749d9b30

@ -119,10 +119,6 @@
android:name=".activities.FilterSelectionActivity"
android:theme="@style/TranslucentDialog"/>
<activity
android:name=".activities.AddAttachmentActivity"
android:theme="@style/TranslucentDialog"/>
<activity
android:name=".activities.CameraActivity"
android:theme="@style/TranslucentDialog"/>
@ -324,13 +320,6 @@
android:name="com.todoroo.astrid.core.OldTaskPreferences"
android:theme="@style/Tasks"/>
<!-- premium -->
<activity
android:configChanges="orientation|screenSize"
android:name="com.todoroo.astrid.files.AACRecordingActivity"
android:screenOrientation="portrait"
android:theme="@style/TranslucentDialog"/>
<activity
android:label="@string/app_name"
android:name=".files.MyFilePickerActivity"

@ -1,77 +0,0 @@
/**
* Copyright (c) 2012 Todoroo Inc
*
* <p>See the file "LICENSE" for the full license governing this code.
*/
package com.todoroo.astrid.files;
import static org.tasks.PermissionUtil.verifyPermissions;
import static org.tasks.dialogs.RecordAudioDialog.newRecordAudioDialog;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v4.app.FragmentManager;
import javax.inject.Inject;
import org.tasks.dialogs.RecordAudioDialog;
import org.tasks.injection.ActivityComponent;
import org.tasks.injection.InjectingAppCompatActivity;
import org.tasks.preferences.ActivityPermissionRequestor;
import org.tasks.preferences.PermissionRequestor;
import org.tasks.themes.Theme;
public class AACRecordingActivity extends InjectingAppCompatActivity
implements RecordAudioDialog.RecordAudioDialogCallback {
public static final String RESULT_OUTFILE = "outfile"; // $NON-NLS-1$
private static final String FRAG_TAG_RECORD_AUDIO = "frag_tag_record_audio";
@Inject ActivityPermissionRequestor permissionRequestor;
@Inject Theme theme;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
theme.applyToContext(this);
if (permissionRequestor.requestMic()) {
showDialog();
}
}
private void showDialog() {
FragmentManager supportFragmentManager = getSupportFragmentManager();
RecordAudioDialog dialog =
(RecordAudioDialog) supportFragmentManager.findFragmentByTag(FRAG_TAG_RECORD_AUDIO);
if (dialog == null) {
dialog = newRecordAudioDialog();
dialog.show(supportFragmentManager, FRAG_TAG_RECORD_AUDIO);
}
}
@Override
public void inject(ActivityComponent component) {
component.inject(this);
}
@Override
public void onRequestPermissionsResult(
int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
if (requestCode == PermissionRequestor.REQUEST_MIC) {
if (verifyPermissions(grantResults)) {
showDialog();
} else {
finish();
}
} else {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
}
}
@Override
public void finished(String path) {
Intent result = new Intent();
result.putExtra(RESULT_OUTFILE, path);
setResult(RESULT_OK, result);
finish();
}
}

@ -5,12 +5,19 @@
*/
package com.todoroo.astrid.files;
import static android.app.Activity.RESULT_OK;
import static com.google.common.base.Strings.isNullOrEmpty;
import static org.tasks.dialogs.AddAttachmentDialog.REQUEST_STORAGE;
import static org.tasks.dialogs.AddAttachmentDialog.newAddAttachmentDialog;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.ActivityNotFoundException;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.text.TextUtils;
@ -27,17 +34,24 @@ import com.google.common.base.Strings;
import com.todoroo.andlib.utility.AndroidUtilities;
import com.todoroo.astrid.data.Task;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import javax.inject.Inject;
import org.tasks.R;
import org.tasks.activities.AddAttachmentActivity;
import org.tasks.activities.CameraActivity;
import org.tasks.data.TaskAttachment;
import org.tasks.data.TaskAttachmentDao;
import org.tasks.dialogs.AddAttachmentDialog;
import org.tasks.dialogs.DialogBuilder;
import org.tasks.files.FileExplore;
import org.tasks.files.FileHelper;
import org.tasks.injection.ForActivity;
import org.tasks.injection.FragmentComponent;
import org.tasks.preferences.Preferences;
import org.tasks.ui.TaskEditControlFragment;
import timber.log.Timber;
@ -45,12 +59,13 @@ public class FilesControlSet extends TaskEditControlFragment {
public static final int TAG = R.string.TEA_ctrl_files_pref;
private static final String FRAG_TAG_ADD_ATTACHMENT_DIALOG = "frag_tag_add_attachment_dialog";
private static final char LEFT_TO_RIGHT_MARK = '\u200e';
private static final int REQUEST_ADD_ATTACHMENT = 50;
@Inject TaskAttachmentDao taskAttachmentDao;
@Inject DialogBuilder dialogBuilder;
@Inject @ForActivity Context context;
@Inject Preferences preferences;
@BindView(R.id.attachment_container)
LinearLayout attachmentContainer;
@ -92,8 +107,8 @@ public class FilesControlSet extends TaskEditControlFragment {
@OnClick(R.id.add_attachment)
void addAttachment(View view) {
startActivityForResult(
new Intent(context, AddAttachmentActivity.class), REQUEST_ADD_ATTACHMENT);
newAddAttachmentDialog(this)
.show(getFragmentManager(), FRAG_TAG_ADD_ATTACHMENT_DIALOG);
}
@Override
@ -116,12 +131,46 @@ public class FilesControlSet extends TaskEditControlFragment {
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == REQUEST_ADD_ATTACHMENT) {
if (requestCode == AddAttachmentDialog.REQUEST_CAMERA) {
if (resultCode == RESULT_OK) {
Uri uri = data.getParcelableExtra(CameraActivity.EXTRA_URI);
final File file = new File(uri.getPath());
String path = file.getPath();
Timber.i("Saved %s", file.getAbsolutePath());
final String extension = path.substring(path.lastIndexOf('.') + 1);
createNewFileAttachment(file, TaskAttachment.FILE_TYPE_IMAGE + extension);
}
} else if (requestCode == AddAttachmentDialog.REQUEST_AUDIO) {
if (resultCode == Activity.RESULT_OK) {
String path = data.getStringExtra(AddAttachmentActivity.EXTRA_PATH);
String type = data.getStringExtra(AddAttachmentActivity.EXTRA_TYPE);
File file = new File(path);
createNewFileAttachment(path, file.getName(), type);
String path = data.getStringExtra(AddAttachmentDialog.EXTRA_PATH);
String type = data.getStringExtra(AddAttachmentDialog.EXTRA_TYPE);
createNewFileAttachment(new File(path), type);
}
} else if (requestCode == AddAttachmentDialog.REQUEST_GALLERY) {
if (resultCode == RESULT_OK) {
Uri uri = data.getData();
ContentResolver contentResolver = context.getContentResolver();
MimeTypeMap mime = MimeTypeMap.getSingleton();
final String extension = mime.getExtensionFromMimeType(contentResolver.getType(uri));
final File tempFile = getFilename(extension);
Timber.i("Writing %s to %s", uri, tempFile);
try {
InputStream inputStream = contentResolver.openInputStream(uri);
copyFile(inputStream, tempFile.getPath());
} catch (IOException e) {
throw new RuntimeException(e);
}
createNewFileAttachment(tempFile, TaskAttachment.FILE_TYPE_IMAGE + extension);
}
} else if (requestCode == REQUEST_STORAGE) {
if (resultCode == RESULT_OK) {
String path = data.getStringExtra(FileExplore.EXTRA_FILE);
final String destination = copyToAttachmentDirectory(path);
if (destination != null) {
Timber.i("Copied %s to %s", path, destination);
final String extension = destination.substring(path.lastIndexOf('.') + 1);
createNewFileAttachment(new File(path), TaskAttachment.FILE_TYPE_IMAGE + extension);
}
}
} else {
super.onActivityResult(requestCode, resultCode, data);
@ -234,13 +283,64 @@ public class FilesControlSet extends TaskEditControlFragment {
}
}
private void createNewFileAttachment(String path, String fileName, String fileType) {
private void createNewFileAttachment(File file, String fileType) {
TaskAttachment attachment =
TaskAttachment.createNewAttachment(taskUuid, path, fileName, fileType);
TaskAttachment.createNewAttachment(
taskUuid, file.getAbsolutePath(), file.getName(), fileType);
taskAttachmentDao.createNew(attachment);
addAttachment(attachment);
}
private File getFilename(String extension) {
AtomicReference<String> nameRef = new AtomicReference<>();
if (isNullOrEmpty(extension)) {
extension = "";
} else if (!extension.startsWith(".")) {
extension = "." + extension;
}
try {
String path = preferences.getNewAttachmentPath(extension, nameRef);
File file = new File(path);
file.getParentFile().mkdirs();
if (!file.createNewFile()) {
throw new RuntimeException("Failed to create " + file.getPath());
}
return file;
} catch (IOException e) {
Timber.e(e);
}
return null;
}
private void copyFile(InputStream inputStream, String to) throws IOException {
FileOutputStream fos = new FileOutputStream(to);
byte[] buf = new byte[1024];
int len;
while ((len = inputStream.read(buf)) != -1) {
fos.write(buf, 0, len);
}
fos.close();
}
private String copyToAttachmentDirectory(String file) {
File src = new File(file);
if (!src.exists()) {
Toast.makeText(context, R.string.file_err_copy, Toast.LENGTH_LONG).show();
return null;
}
File dst = new File(preferences.getAttachmentsDirectory() + File.separator + src.getName());
try {
AndroidUtilities.copyFile(src, dst);
} catch (Exception e) {
Timber.e(e);
Toast.makeText(context, R.string.file_err_copy, Toast.LENGTH_LONG).show();
return null;
}
return dst.getAbsolutePath();
}
interface PlaybackExceptionHandler {
void playbackFailed();

@ -1,24 +1,31 @@
package com.todoroo.astrid.voice;
import android.annotation.TargetApi;
import android.arch.lifecycle.ViewModel;
import android.media.MediaRecorder;
import android.os.Build;
import android.os.SystemClock;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicReference;
import org.tasks.preferences.Preferences;
import timber.log.Timber;
public class AACRecorder {
public class AACRecorder extends ViewModel {
private MediaRecorder mediaRecorder;
private final AtomicReference<String> nameRef = new AtomicReference<>();
private boolean recording;
private AACRecorderCallbacks listener;
private Preferences preferences;
private long base;
private String tempFile;
@TargetApi(Build.VERSION_CODES.GINGERBREAD_MR1)
public synchronized void startRecording(final String tempFile) {
public synchronized void startRecording() {
if (recording) {
return;
}
tempFile = preferences.getNewAudioAttachmentPath(nameRef);
mediaRecorder = new MediaRecorder();
mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
@ -36,6 +43,7 @@ public class AACRecorder {
}
recording = true;
base = SystemClock.elapsedRealtime();
mediaRecorder.start();
}
@ -55,16 +63,21 @@ public class AACRecorder {
mediaRecorder.release();
recording = false;
if (listener != null) {
listener.encodingFinished();
listener.encodingFinished(tempFile);
}
}
public void setListener(AACRecorderCallbacks listener) {
public long getBase() {
return base;
}
public void init(AACRecorderCallbacks listener, Preferences preferences) {
this.listener = listener;
this.preferences = preferences;
}
public interface AACRecorderCallbacks {
void encodingFinished();
void encodingFinished(String path);
}
}

@ -1,206 +0,0 @@
package org.tasks.activities;
import static com.google.common.base.Strings.isNullOrEmpty;
import android.content.ContentResolver;
import android.content.DialogInterface;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.support.v4.app.FragmentManager;
import android.webkit.MimeTypeMap;
import android.widget.Toast;
import com.todoroo.andlib.utility.AndroidUtilities;
import com.todoroo.astrid.files.AACRecordingActivity;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.atomic.AtomicReference;
import javax.inject.Inject;
import org.tasks.R;
import org.tasks.data.TaskAttachment;
import org.tasks.dialogs.AddAttachmentDialog;
import org.tasks.files.FileExplore;
import org.tasks.injection.ActivityComponent;
import org.tasks.injection.InjectingAppCompatActivity;
import org.tasks.preferences.Preferences;
import timber.log.Timber;
public class AddAttachmentActivity extends InjectingAppCompatActivity
implements DialogInterface.OnCancelListener, AddAttachmentDialog.AddAttachmentCallback {
public static final String EXTRA_PATH = "extra_path";
public static final String EXTRA_TYPE = "extra_type";
private static final String FRAG_TAG_ATTACHMENT_DIALOG = "frag_tag_attachment_dialog";
private static final int REQUEST_CAMERA = 12120;
private static final int REQUEST_GALLERY = 12121;
private static final int REQUEST_STORAGE = 12122;
private static final int REQUEST_CODE_RECORD = 12123;
@Inject Preferences preferences;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
FragmentManager fragmentManager = getSupportFragmentManager();
AddAttachmentDialog dialog =
(AddAttachmentDialog) fragmentManager.findFragmentByTag(FRAG_TAG_ATTACHMENT_DIALOG);
if (dialog == null) {
dialog = new AddAttachmentDialog();
dialog.show(fragmentManager, FRAG_TAG_ATTACHMENT_DIALOG);
}
dialog.setOnCancelListener(this);
dialog.setAddAttachmentCallback(this);
}
@Override
public void inject(ActivityComponent component) {
component.inject(this);
}
@Override
public void onCancel(DialogInterface dialog) {
finish();
}
@Override
public void takePicture() {
startActivityForResult(new Intent(this, CameraActivity.class), REQUEST_CAMERA);
}
@Override
public void recordNote() {
startActivityForResult(new Intent(this, AACRecordingActivity.class), REQUEST_CODE_RECORD);
}
@Override
public void pickFromGallery() {
Intent intent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
intent.setType("image/*");
if (intent.resolveActivity(getPackageManager()) != null) {
startActivityForResult(intent, REQUEST_GALLERY);
}
}
@Override
public void pickFromStorage() {
startActivityForResult(new Intent(this, FileExplore.class), REQUEST_STORAGE);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, final Intent data) {
if (requestCode == REQUEST_CAMERA) {
if (resultCode == RESULT_OK) {
Uri uri = data.getParcelableExtra(CameraActivity.EXTRA_URI);
final File file = new File(uri.getPath());
String path = file.getPath();
Timber.i("Saved %s", file.getAbsolutePath());
final String extension = path.substring(path.lastIndexOf('.') + 1);
Intent intent = new Intent();
intent.putExtra(EXTRA_PATH, file.getAbsolutePath());
intent.putExtra(EXTRA_TYPE, TaskAttachment.FILE_TYPE_IMAGE + extension);
setResult(RESULT_OK, intent);
}
finish();
} else if (requestCode == REQUEST_CODE_RECORD) {
if (resultCode == RESULT_OK) {
final String recordedAudioPath = data.getStringExtra(AACRecordingActivity.RESULT_OUTFILE);
final String extension =
recordedAudioPath.substring(recordedAudioPath.lastIndexOf('.') + 1);
Intent intent = new Intent();
intent.putExtra(EXTRA_PATH, recordedAudioPath);
intent.putExtra(EXTRA_TYPE, TaskAttachment.FILE_TYPE_AUDIO + extension);
setResult(RESULT_OK, intent);
}
finish();
} else if (requestCode == REQUEST_GALLERY) {
if (resultCode == RESULT_OK) {
Uri uri = data.getData();
ContentResolver contentResolver = getContentResolver();
MimeTypeMap mime = MimeTypeMap.getSingleton();
final String extension = mime.getExtensionFromMimeType(contentResolver.getType(uri));
final File tempFile = getFilename(extension);
Timber.i("Writing %s to %s", uri, tempFile);
try {
InputStream inputStream = contentResolver.openInputStream(uri);
copyFile(inputStream, tempFile.getPath());
} catch (IOException e) {
throw new RuntimeException(e);
}
Intent intent = new Intent();
intent.putExtra(EXTRA_PATH, tempFile.getAbsolutePath());
intent.putExtra(EXTRA_TYPE, TaskAttachment.FILE_TYPE_IMAGE + extension);
setResult(RESULT_OK, intent);
}
finish();
} else if (requestCode == REQUEST_STORAGE) {
if (resultCode == RESULT_OK) {
String path = data.getStringExtra(FileExplore.EXTRA_FILE);
final String destination = copyToAttachmentDirectory(path);
if (destination != null) {
Timber.i("Copied %s to %s", path, destination);
final String extension = destination.substring(path.lastIndexOf('.') + 1);
Intent intent = new Intent();
intent.putExtra(EXTRA_PATH, destination);
intent.putExtra(EXTRA_TYPE, TaskAttachment.FILE_TYPE_IMAGE + extension);
setResult(RESULT_OK, intent);
}
}
finish();
} else {
super.onActivityResult(requestCode, resultCode, data);
}
}
private File getFilename(String extension) {
AtomicReference<String> nameRef = new AtomicReference<>();
if (isNullOrEmpty(extension)) {
extension = "";
} else if (!extension.startsWith(".")) {
extension = "." + extension;
}
try {
String path = preferences.getNewAttachmentPath(extension, nameRef);
File file = new File(path);
file.getParentFile().mkdirs();
if (!file.createNewFile()) {
throw new RuntimeException("Failed to create " + file.getPath());
}
return file;
} catch (IOException e) {
Timber.e(e);
}
return null;
}
private void copyFile(InputStream inputStream, String to) throws IOException {
FileOutputStream fos = new FileOutputStream(to);
byte[] buf = new byte[1024];
int len;
while ((len = inputStream.read(buf)) != -1) {
fos.write(buf, 0, len);
}
fos.close();
}
private String copyToAttachmentDirectory(String file) {
File src = new File(file);
if (!src.exists()) {
Toast.makeText(this, R.string.file_err_copy, Toast.LENGTH_LONG).show();
return null;
}
File dst = new File(preferences.getAttachmentsDirectory() + File.separator + src.getName());
try {
AndroidUtilities.copyFile(src, dst);
} catch (Exception e) {
Timber.e(e);
Toast.makeText(this, R.string.file_err_copy, Toast.LENGTH_LONG).show();
return null;
}
return dst.getAbsolutePath();
}
}

@ -1,24 +1,47 @@
package org.tasks.dialogs;
import static com.google.common.collect.Lists.newArrayList;
import static org.tasks.dialogs.RecordAudioDialog.newRecordAudioDialog;
import android.app.Dialog;
import android.content.DialogInterface;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.provider.MediaStore.Images.Media;
import android.support.annotation.NonNull;
import com.todoroo.astrid.files.FilesControlSet;
import java.util.List;
import javax.inject.Inject;
import org.tasks.R;
import org.tasks.activities.CameraActivity;
import org.tasks.files.FileExplore;
import org.tasks.injection.DialogFragmentComponent;
import org.tasks.injection.ForActivity;
import org.tasks.injection.InjectingDialogFragment;
import org.tasks.preferences.Device;
import org.tasks.preferences.Preferences;
public class AddAttachmentDialog extends InjectingDialogFragment {
private static final String FRAG_TAG_RECORD_AUDIO = "frag_tag_record_audio";
public static final int REQUEST_CAMERA = 12120;
public static final int REQUEST_GALLERY = 12121;
public static final int REQUEST_STORAGE = 12122;
public static final int REQUEST_AUDIO = 12123;
public static final String EXTRA_PATH = "extra_path";
public static final String EXTRA_TYPE = "extra_type";
@Inject @ForActivity Context context;
@Inject DialogBuilder dialogBuilder;
@Inject Device device;
private AddAttachmentCallback callback;
private DialogInterface.OnCancelListener onCancelListener;
@Inject Preferences preferences;
public static AddAttachmentDialog newAddAttachmentDialog(FilesControlSet target) {
AddAttachmentDialog dialog = new AddAttachmentDialog();
dialog.setTargetFragment(target, 0);
return dialog;
}
@Override
protected void inject(DialogFragmentComponent component) {
@ -32,47 +55,40 @@ public class AddAttachmentDialog extends InjectingDialogFragment {
final List<Runnable> actions = newArrayList();
if (device.hasCamera()) {
entries.add(getString(R.string.take_a_picture));
actions.add(() -> callback.takePicture());
actions.add(this::takePicture);
}
entries.add(getString(R.string.premium_record_audio));
actions.add(() -> callback.recordNote());
actions.add(this::recordNote);
if (device.hasGallery()) {
entries.add(getString(R.string.pick_from_gallery));
actions.add(() -> callback.pickFromGallery());
actions.add(this::pickFromGallery);
}
entries.add(getString(R.string.pick_from_storage));
actions.add(() -> callback.pickFromStorage());
actions.add(this::pickFromStorage);
return dialogBuilder
.newDialog()
.setItems(entries, (dialog, which) -> actions.get(which).run())
.show();
}
@Override
public void onCancel(DialogInterface dialog) {
super.onCancel(dialog);
if (onCancelListener != null) {
onCancelListener.onCancel(dialog);
}
private void takePicture() {
getTargetFragment().startActivityForResult(new Intent(context, CameraActivity.class), REQUEST_CAMERA);
}
public void setAddAttachmentCallback(AddAttachmentCallback callback) {
this.callback = callback;
private void recordNote() {
newRecordAudioDialog((FilesControlSet) getTargetFragment(), REQUEST_AUDIO)
.show(getFragmentManager(), FRAG_TAG_RECORD_AUDIO);
}
public void setOnCancelListener(DialogInterface.OnCancelListener onCancelListener) {
this.onCancelListener = onCancelListener;
private void pickFromGallery() {
Intent intent = new Intent(Intent.ACTION_PICK);
intent.setDataAndType(Media.EXTERNAL_CONTENT_URI, "image/*");
if (intent.resolveActivity(context.getPackageManager()) != null) {
getTargetFragment().startActivityForResult(intent, REQUEST_GALLERY);
}
}
public interface AddAttachmentCallback {
void takePicture();
void recordNote();
void pickFromGallery();
void pickFromStorage();
public void pickFromStorage() {
getTargetFragment().startActivityForResult(new Intent(context, FileExplore.class), REQUEST_STORAGE);
}
}

@ -1,41 +1,54 @@
package org.tasks.dialogs;
import android.app.Activity;
import static android.app.Activity.RESULT_OK;
import static org.tasks.PermissionUtil.verifyPermissions;
import static org.tasks.dialogs.AddAttachmentDialog.EXTRA_PATH;
import static org.tasks.dialogs.AddAttachmentDialog.EXTRA_TYPE;
import android.app.Dialog;
import android.arch.lifecycle.ViewModelProviders;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.Chronometer;
import butterknife.BindView;
import butterknife.ButterKnife;
import butterknife.OnClick;
import com.todoroo.astrid.files.FilesControlSet;
import com.todoroo.astrid.voice.AACRecorder;
import java.util.concurrent.atomic.AtomicReference;
import javax.inject.Inject;
import org.tasks.R;
import org.tasks.data.TaskAttachment;
import org.tasks.injection.DialogFragmentComponent;
import org.tasks.injection.InjectingDialogFragment;
import org.tasks.preferences.FragmentPermissionRequestor;
import org.tasks.preferences.PermissionChecker;
import org.tasks.preferences.PermissionRequestor;
import org.tasks.preferences.Preferences;
import org.tasks.themes.Theme;
public class RecordAudioDialog extends InjectingDialogFragment
implements AACRecorder.AACRecorderCallbacks {
private final AtomicReference<String> nameRef = new AtomicReference<>();
@Inject Preferences preferences;
@Inject DialogBuilder dialogBuilder;
@Inject Theme theme;
@Inject FragmentPermissionRequestor permissionRequestor;
@Inject PermissionChecker permissionChecker;
@BindView(R.id.timer)
Chronometer timer;
private AACRecorder recorder;
private String tempFile;
private RecordAudioDialogCallback callback;
public static RecordAudioDialog newRecordAudioDialog() {
return new RecordAudioDialog();
public static RecordAudioDialog newRecordAudioDialog(FilesControlSet target, int requestCode) {
RecordAudioDialog dialog = new RecordAudioDialog();
dialog.setTargetFragment(target, requestCode);
return dialog;
}
@NonNull
@ -45,7 +58,14 @@ public class RecordAudioDialog extends InjectingDialogFragment
View view = layoutInflater.inflate(R.layout.aac_record_activity, null);
ButterKnife.bind(this, view);
startRecording();
recorder = ViewModelProviders.of(this).get(AACRecorder.class);
recorder.init(this, preferences);
if (permissionChecker.canAccessMic()) {
startRecording();
} else if (savedInstanceState == null) {
permissionRequestor.requestMic();
}
return dialogBuilder
.newDialog()
@ -54,34 +74,23 @@ public class RecordAudioDialog extends InjectingDialogFragment
.create();
}
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
callback = (RecordAudioDialogCallback) activity;
private void startRecording() {
recorder.startRecording();
timer.setBase(recorder.getBase());
timer.start();
}
@Override
public void onPause() {
super.onPause();
public void onCancel(DialogInterface dialog) {
super.onCancel(dialog);
stopRecording();
}
@OnClick(R.id.stop_recording)
void stopRecording() {
if (recorder != null) {
recorder.stopRecording();
timer.stop();
}
}
private void startRecording() {
tempFile = preferences.getNewAudioAttachmentPath(nameRef);
recorder = new AACRecorder();
recorder.setListener(this);
recorder.startRecording(tempFile);
timer.start();
recorder.stopRecording();
timer.stop();
}
@Override
@ -90,12 +99,29 @@ public class RecordAudioDialog extends InjectingDialogFragment
}
@Override
public void encodingFinished() {
callback.finished(tempFile);
public void encodingFinished(String path) {
final String extension = path.substring(path.lastIndexOf('.') + 1);
Intent intent = new Intent();
intent.putExtra(EXTRA_PATH, path);
intent.putExtra(EXTRA_TYPE, TaskAttachment.FILE_TYPE_AUDIO + extension);
Fragment target = getTargetFragment();
if (target != null) {
target.onActivityResult(getTargetRequestCode(), RESULT_OK, intent);
}
dismiss();
}
public interface RecordAudioDialogCallback {
void finished(String path);
@Override
public void onRequestPermissionsResult(
int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
if (requestCode == PermissionRequestor.REQUEST_MIC) {
if (verifyPermissions(grantResults)) {
startRecording();
} else {
dismiss();
}
} else {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
}
}
}

@ -6,12 +6,10 @@ import com.todoroo.astrid.activity.ShareLinkActivity;
import com.todoroo.astrid.core.CustomFilterActivity;
import com.todoroo.astrid.core.DefaultsPreferences;
import com.todoroo.astrid.core.OldTaskPreferences;
import com.todoroo.astrid.files.AACRecordingActivity;
import com.todoroo.astrid.gcal.CalendarReminderActivity;
import com.todoroo.astrid.gtasks.auth.GtasksLoginActivity;
import com.todoroo.astrid.reminders.ReminderPreferences;
import dagger.Subcomponent;
import org.tasks.activities.AddAttachmentActivity;
import org.tasks.activities.CalendarSelectionActivity;
import org.tasks.activities.CameraActivity;
import org.tasks.activities.ColorPickerActivity;
@ -64,8 +62,6 @@ public interface ActivityComponent {
void inject(DashClockSettings dashClockSettings);
void inject(AACRecordingActivity aacRecordingActivity);
void inject(CustomFilterActivity customFilterActivity);
void inject(CalendarReminderActivity calendarReminderActivity);
@ -94,8 +90,6 @@ public interface ActivityComponent {
void inject(DateAndTimePickerActivity dateAndTimePickerActivity);
void inject(AddAttachmentActivity addAttachmentActivity);
void inject(DatePickerActivity datePickerActivity);
void inject(CameraActivity cameraActivity);

Loading…
Cancel
Save