mirror/Anki-Android
0
0
Fork 0
mirror of https://github.com/ankidroid/Anki-Android.git synced 2024-09-20 03:52:15 +02:00
Code

Migrate TaskListenerWithContext.java to Kotlin

Browse Source
This commit is contained in:
Kilian Trosien 2022-03-11 16:45:02 +01:00 committed by Mike Hardy
parent d18e2c8139
commit d2475449d4
4 changed files with 39 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
AnkiDroid/kotlinMigration.gradle
View File

@ -43,7 +43,7 @@ permission notice:
// Example of class name: "/com/ichi2/anki/UIUtils.kt"
// Ensure that it starts with '/' (slash)
def source = Source.MAIN
def className = "/com/ichi2/async/TaskListenerWithContext.kt"
def className = ""
enum Source {
MAIN("/src/main/java"),

12
AnkiDroid/src/main/java/com/ichi2/anki/dialogs/customstudy/CreateCustomStudySessionListener.kt
View File

@ -18,19 +18,19 @@ package com.ichi2.anki.dialogs.customstudy
import com.ichi2.anki.StudyOptionsFragment.DeckStudyData
import com.ichi2.async.TaskListenerWithContext
class CreateCustomStudySessionListener(callback: Callback?) : TaskListenerWithContext<CreateCustomStudySessionListener.Callback?, Void?, DeckStudyData?>(callback) {
class CreateCustomStudySessionListener(callback: Callback?) : TaskListenerWithContext<CreateCustomStudySessionListener.Callback, Void?, DeckStudyData?>(callback) {
interface Callback {
fun hideProgressBar()
fun onCreateCustomStudySession()
fun showProgressBar()
}
override fun actualOnPreExecute(callback: Callback) {
callback.showProgressBar()
override fun actualOnPreExecute(context: Callback) {
context.showProgressBar()
}
override fun actualOnPostExecute(callback: Callback, result: DeckStudyData?) {
callback.hideProgressBar()
callback.onCreateCustomStudySession()
override fun actualOnPostExecute(context: Callback, result: DeckStudyData?) {
context.hideProgressBar()
context.onCreateCustomStudySession()
}
}

16
AnkiDroid/src/main/java/com/ichi2/anki/export/ExportListener.kt
View File

@ -24,16 +24,16 @@ import com.ichi2.async.TaskListenerWithContext
import com.ichi2.themes.StyledProgressDialog
import timber.log.Timber
internal class ExportListener(activity: AnkiActivity?, private val dialogsFactory: ExportDialogsFactory) : TaskListenerWithContext<AnkiActivity?, Void?, Pair<Boolean?, String?>?>(activity) {
internal class ExportListener(activity: AnkiActivity?, private val dialogsFactory: ExportDialogsFactory) : TaskListenerWithContext<AnkiActivity, Void?, Pair<Boolean?, String?>?>(activity) {
private var mProgressDialog: MaterialDialog? = null
override fun actualOnPreExecute(activity: AnkiActivity) {
override fun actualOnPreExecute(context: AnkiActivity) {
mProgressDialog = StyledProgressDialog.show(
activity, "",
activity.resources.getString(R.string.export_in_progress), false
context, "",
context.resources.getString(R.string.export_in_progress), false
)
}
override fun actualOnPostExecute(activity: AnkiActivity, result: Pair<Boolean?, String?>?) {
override fun actualOnPostExecute(context: AnkiActivity, result: Pair<Boolean?, String?>?) {
if (mProgressDialog != null && mProgressDialog!!.isShowing) {
mProgressDialog!!.dismiss()
}
@ -45,15 +45,15 @@ internal class ExportListener(activity: AnkiActivity?, private val dialogsFactor
// instead of a successful result.
if (result.first == true && result.second != null) {
Timber.w("Export Failed: %s", result.second)
activity.showSimpleMessageDialog(result.second)
context.showSimpleMessageDialog(result.second)
} else {
Timber.i("Export successful")
val exportPath = result.second
if (exportPath != null) {
val dialog = dialogsFactory.newExportCompleteDialog().withArguments(exportPath)
activity.showAsyncDialogFragment(dialog)
context.showAsyncDialogFragment(dialog)
} else {
showThemedToast(activity, activity.resources.getString(R.string.export_unsuccessful), true)
showThemedToast(context, context.resources.getString(R.string.export_unsuccessful), true)
}
}
}

69
AnkiDroid/src/main/java/com/ichi2/async/TaskListenerWithContext.kt
View File

@ -13,79 +13,58 @@
* You should have received a copy of the GNU General Public License along with *
* this program. If not, see <http://www.gnu.org/licenses/>. *
****************************************************************************************/
package com.ichi2.async
package com.ichi2.async;
import java.lang.ref.WeakReference;
import androidx.annotation.NonNull;
import java.lang.ref.WeakReference
/** Similar to task listener, but if the context disappear, no action are executed.
* We ensure that the context can't disappear during the execution of the methods. */
public abstract class TaskListenerWithContext<CTX, Progress, Result> extends TaskListener<Progress, Result> {
private final WeakReference<CTX> mContext;
protected TaskListenerWithContext(CTX context) {
mContext = new WeakReference<>(context);
abstract class TaskListenerWithContext<CTX, Progress, Result> protected constructor(context: CTX?) : TaskListener<Progress, Result>() {
private val mContext: WeakReference<CTX>
override fun onPreExecute() {
val context = mContext.get()
context?.let { actualOnPreExecute(it) }
}
final public void onPreExecute() {
CTX context = mContext.get();
if (context != null) {
actualOnPreExecute(context);
}
override fun onProgressUpdate(value: Progress) {
val context = mContext.get()
context?.let { actualOnProgressUpdate(it, value) }
}
final public void onProgressUpdate(Progress value) {
CTX context = mContext.get();
if (context != null) {
actualOnProgressUpdate(context, value);
}
}
/**
* Invoked when the background task publishes an update.
* <p>
* The semantics of the update data depends on the task itself.
* Assumes context exists.
*/
public void actualOnProgressUpdate(@NonNull CTX context, Progress value) {
open fun actualOnProgressUpdate(context: CTX, value: Progress) {
// most implementations do nothing with this, provide them a default implementation
}
/** Invoked before the task is started. Assumes context exists. */
public abstract void actualOnPreExecute(@NonNull CTX context);
final public void onPostExecute(Result result) {
CTX context = mContext.get();
if (context != null) {
actualOnPostExecute(context, result);
}
abstract fun actualOnPreExecute(context: CTX)
override fun onPostExecute(result: Result) {
val context = mContext.get()
context?.let { actualOnPostExecute(it, result) }
}
/**
* Invoked after the task has completed.
* <p>
* The semantics of the result depends on the task itself.
*/
public abstract void actualOnPostExecute(@NonNull CTX context, Result result);
public void onCancelled() {
CTX context = mContext.get();
if (context != null) {
actualOnCancelled(context);
}
abstract fun actualOnPostExecute(context: CTX, result: Result)
override fun onCancelled() {
val context = mContext.get()
context?.let { actualOnCancelled(it) }
}
/** Assumes context exists. */
public void actualOnCancelled(@NonNull CTX context) {
open fun actualOnCancelled(context: CTX) {
// most implementations do nothing with this, provide them a default implementation
}
init {
mContext = WeakReference(context)
}
}