rework backup & restore

use the implementation from Conversations

2 files changed, 244 insertions, 71 deletions

diff --git a/src/main/java/de/pixart/messenger/ui/adapter/AccountAdapter.java b/src/main/java/de/pixart/messenger/ui/adapter/AccountAdapter.java
index 391fee0b9..e060d8828 100644
--- a/src/main/java/de/pixart/messenger/ui/adapter/AccountAdapter.java
+++ b/src/main/java/de/pixart/messenger/ui/adapter/AccountAdapter.java
@@ -1,19 +1,17 @@
 package de.pixart.messenger.ui.adapter;
 
-import android.content.Context;
 import android.content.res.Resources;
+import android.databinding.DataBindingUtil;
 import android.graphics.Bitmap;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.os.AsyncTask;
 import android.support.annotation.NonNull;
-import android.support.v7.widget.SwitchCompat;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.ArrayAdapter;
 import android.widget.ImageView;
-import android.widget.TextView;
 
 import java.lang.ref.WeakReference;
 import java.util.List;
@@ -21,8 +19,8 @@ import java.util.concurrent.RejectedExecutionException;
 
 import de.pixart.messenger.Config;
 import de.pixart.messenger.R;
+import de.pixart.messenger.databinding.AccountRowBinding;
 import de.pixart.messenger.entities.Account;
-import de.pixart.messenger.ui.ManageAccountActivity;
 import de.pixart.messenger.ui.XmppActivity;
 import de.pixart.messenger.ui.util.StyledAttributes;
 import de.pixart.messenger.utils.UIHelper;
@@ -44,47 +42,46 @@ public class AccountAdapter extends ArrayAdapter<Account> {
         this.showStateButton = true;
     }
 
-    @NonNull
     @Override
     public View getView(int position, View view, @NonNull ViewGroup parent) {
         final Account account = getItem(position);
+        final ViewHolder viewHolder;
         if (view == null) {
-            LayoutInflater inflater = (LayoutInflater) getContext()
-                    .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
-            view = inflater.inflate(R.layout.account_row, parent, false);
+            AccountRowBinding binding = DataBindingUtil.inflate(LayoutInflater.from(parent.getContext()), R.layout.account_row, parent, false);
+            view = binding.getRoot();
+            viewHolder = new ViewHolder(binding);
+            view.setTag(viewHolder);
+        } else {
+            viewHolder = (ViewHolder) view.getTag();
         }
-        TextView jid = view.findViewById(R.id.account_jid);
         if (Config.DOMAIN_LOCK != null) {
-            jid.setText(account.getJid().getLocal());
+            viewHolder.binding.accountJid.setText(account.getJid().getLocal());
         } else {
-            jid.setText(account.getJid().asBareJid().toString());
+            viewHolder.binding.accountJid.setText(account.getJid().asBareJid().toString());
         }
-        TextView statusView = view.findViewById(R.id.account_status);
-        ImageView imageView = view.findViewById(R.id.account_image);
-        loadAvatar(account,imageView);
-        statusView.setText(getContext().getString(account.getStatus().getReadableId()));
+        loadAvatar(account, viewHolder.binding.accountImage);
+        viewHolder.binding.accountStatus.setText(getContext().getString(account.getStatus().getReadableId()));
         switch (account.getStatus()) {
             case ONLINE:
-                statusView.setTextColor(StyledAttributes.getColor(activity, R.attr.TextColorOnline));
+                viewHolder.binding.accountStatus.setTextColor(StyledAttributes.getColor(activity, R.attr.TextColorOnline));
                 break;
             case DISABLED:
             case CONNECTING:
-                statusView.setTextColor(StyledAttributes.getColor(activity, android.R.attr.textColorSecondary));
+                viewHolder.binding.accountStatus.setTextColor(StyledAttributes.getColor(activity, android.R.attr.textColorSecondary));
                 break;
             default:
-                statusView.setTextColor(StyledAttributes.getColor(activity, R.attr.TextColorError));
+                viewHolder.binding.accountStatus.setTextColor(StyledAttributes.getColor(activity, R.attr.TextColorError));
                 break;
         }
-        final SwitchCompat tglAccountState = view.findViewById(R.id.tgl_account_status);
         final boolean isDisabled = (account.getStatus() == Account.State.DISABLED);
-        tglAccountState.setOnCheckedChangeListener(null);
-        tglAccountState.setChecked(!isDisabled);
+        viewHolder.binding.tglAccountStatus.setOnCheckedChangeListener(null);
+        viewHolder.binding.tglAccountStatus.setChecked(!isDisabled);
         if (this.showStateButton) {
-            tglAccountState.setVisibility(View.VISIBLE);
+            viewHolder.binding.tglAccountStatus.setVisibility(View.VISIBLE);
         } else {
-            tglAccountState.setVisibility(View.GONE);
+            viewHolder.binding.tglAccountStatus.setVisibility(View.GONE);
         }
-        tglAccountState.setOnCheckedChangeListener((compoundButton, b) -> {
+        viewHolder.binding.tglAccountStatus.setOnCheckedChangeListener((compoundButton, b) -> {
             if (b == isDisabled && activity instanceof OnTglAccountState) {
                 ((OnTglAccountState) activity).onClickTglAccountState(account, b);
             }
@@ -92,6 +89,62 @@ public class AccountAdapter extends ArrayAdapter<Account> {
         return view;
     }
 
+    private static class ViewHolder {
+        private final AccountRowBinding binding;
+
+        private ViewHolder(AccountRowBinding binding) {
+            this.binding = binding;
+        }
+    }
+
+    class BitmapWorkerTask extends AsyncTask<Account, Void, Bitmap> {
+        private final WeakReference<ImageView> imageViewReference;
+        private Account account = null;
+
+        public BitmapWorkerTask(ImageView imageView) {
+            imageViewReference = new WeakReference<>(imageView);
+        }
+
+        @Override
+        protected Bitmap doInBackground(Account... params) {
+            this.account = params[0];
+            return activity.avatarService().get(this.account, activity.getPixel(48), isCancelled());
+        }
+
+        @Override
+        protected void onPostExecute(Bitmap bitmap) {
+            if (bitmap != null && !isCancelled()) {
+                final ImageView imageView = imageViewReference.get();
+                if (imageView != null) {
+                    imageView.setImageBitmap(bitmap);
+                    imageView.setBackgroundColor(0x00000000);
+                }
+            }
+        }
+    }
+
+    public void loadAvatar(Account account, ImageView imageView) {
+        if (cancelPotentialWork(account, imageView)) {
+            final Bitmap bm = activity.avatarService().get(account, activity.getPixel(48), true);
+            if (bm != null) {
+                cancelPotentialWork(account, imageView);
+                imageView.setImageBitmap(bm);
+                imageView.setBackgroundColor(0x00000000);
+            } else {
+                imageView.setBackgroundColor(UIHelper.getColorForName(account.getJid().asBareJid().toString()));
+                imageView.setImageDrawable(null);
+                final BitmapWorkerTask task = new BitmapWorkerTask(imageView);
+                final AsyncDrawable asyncDrawable = new AsyncDrawable(activity.getResources(), null, task);
+                imageView.setImageDrawable(asyncDrawable);
+                try {
+                    task.execute(account);
+                } catch (final RejectedExecutionException ignored) {
+                }
+            }
+        }
+    }
+
+
     public interface OnTglAccountState {
         void onClickTglAccountState(Account account, boolean state);
     }
@@ -121,27 +174,6 @@ public class AccountAdapter extends ArrayAdapter<Account> {
         return null;
     }
 
-    public void loadAvatar(Account account, ImageView imageView) {
-        if (cancelPotentialWork(account, imageView)) {
-            final Bitmap bm = activity.avatarService().get(account, activity.getPixel(56), true);
-            if (bm != null) {
-                cancelPotentialWork(account, imageView);
-                imageView.setImageBitmap(bm);
-                imageView.setBackgroundColor(0x00000000);
-            } else {
-                imageView.setBackgroundColor(UIHelper.getColorForName(account.getJid().asBareJid().toString()));
-                imageView.setImageDrawable(null);
-                final BitmapWorkerTask task = new BitmapWorkerTask(imageView);
-                final AsyncDrawable asyncDrawable = new AsyncDrawable(activity.getResources(), null, task);
-                imageView.setImageDrawable(asyncDrawable);
-                try {
-                    task.executeOnExecutor(BitmapWorkerTask.THREAD_POOL_EXECUTOR, account);
-                } catch (final RejectedExecutionException ignored) {
-                }
-            }
-        }
-    }
-
     static class AsyncDrawable extends BitmapDrawable {
         private final WeakReference<BitmapWorkerTask> bitmapWorkerTaskReference;
 
@@ -154,30 +186,4 @@ public class AccountAdapter extends ArrayAdapter<Account> {
             return bitmapWorkerTaskReference.get();
         }
     }
-
-    class BitmapWorkerTask extends AsyncTask<Account, Void, Bitmap> {
-        private final WeakReference<ImageView> imageViewReference;
-        private Account account = null;
-
-        public BitmapWorkerTask(ImageView imageView) {
-            imageViewReference = new WeakReference<>(imageView);
-        }
-
-        @Override
-        protected Bitmap doInBackground(Account... params) {
-            this.account = params[0];
-            return activity.avatarService().get(this.account, activity.getPixel(56), isCancelled());
-        }
-
-        @Override
-        protected void onPostExecute(Bitmap bitmap) {
-            if (bitmap != null && !isCancelled()) {
-                final ImageView imageView = imageViewReference.get();
-                if (imageView != null) {
-                    imageView.setImageBitmap(bitmap);
-                    imageView.setBackgroundColor(0x00000000);
-                }
-            }
-        }
-    }
 }
diff --git a/src/main/java/de/pixart/messenger/ui/adapter/BackupFileAdapter.java b/src/main/java/de/pixart/messenger/ui/adapter/BackupFileAdapter.java
new file mode 100644
index 000000000..84ae61e11
--- /dev/null
+++ b/src/main/java/de/pixart/messenger/ui/adapter/BackupFileAdapter.java
@@ -0,0 +1,167 @@
+package de.pixart.messenger.ui.adapter;
+
+import android.content.res.Resources;
+import android.databinding.DataBindingUtil;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.AsyncTask;
+import android.support.annotation.NonNull;
+import android.support.v7.widget.RecyclerView;
+import android.text.format.DateUtils;
+import android.util.DisplayMetrics;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.RejectedExecutionException;
+
+import de.pixart.messenger.R;
+import de.pixart.messenger.databinding.AccountRowBinding;
+import de.pixart.messenger.services.AvatarService;
+import de.pixart.messenger.services.ImportBackupService;
+import de.pixart.messenger.utils.BackupFileHeader;
+import de.pixart.messenger.utils.UIHelper;
+import rocks.xmpp.addr.Jid;
+
+public class BackupFileAdapter extends RecyclerView.Adapter<BackupFileAdapter.BackupFileViewHolder> {
+
+    private OnItemClickedListener listener;
+
+    private final List<ImportBackupService.BackupFile> files = new ArrayList<>();
+
+
+    @NonNull
+    @Override
+    public BackupFileViewHolder onCreateViewHolder(@NonNull ViewGroup viewGroup, int i) {
+        return new BackupFileViewHolder(DataBindingUtil.inflate(LayoutInflater.from(viewGroup.getContext()), R.layout.account_row, viewGroup, false));
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull BackupFileViewHolder backupFileViewHolder, int position) {
+        final ImportBackupService.BackupFile backupFile = files.get(position);
+        final BackupFileHeader header = backupFile.getHeader();
+        backupFileViewHolder.binding.accountJid.setText(header.getJid().asBareJid().toString());
+        backupFileViewHolder.binding.accountStatus.setText(String.format("%s · %s", header.getApp(), DateUtils.formatDateTime(backupFileViewHolder.binding.getRoot().getContext(), header.getTimestamp(), DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR)));
+        backupFileViewHolder.binding.tglAccountStatus.setVisibility(View.GONE);
+        backupFileViewHolder.binding.getRoot().setOnClickListener(v -> {
+            if (listener != null) {
+                listener.onClick(backupFile);
+            }
+        });
+        loadAvatar(header.getJid(), backupFileViewHolder.binding.accountImage);
+    }
+
+    @Override
+    public int getItemCount() {
+        return files.size();
+    }
+
+    public void setFiles(List<ImportBackupService.BackupFile> files) {
+        this.files.clear();
+        this.files.addAll(files);
+        notifyDataSetChanged();
+    }
+
+    public void setOnItemClickedListener(OnItemClickedListener listener) {
+        this.listener = listener;
+    }
+
+    static class BackupFileViewHolder extends RecyclerView.ViewHolder {
+        private final AccountRowBinding binding;
+
+        BackupFileViewHolder(AccountRowBinding binding) {
+            super(binding.getRoot());
+            this.binding = binding;
+        }
+    }
+
+    public interface OnItemClickedListener {
+        void onClick(ImportBackupService.BackupFile backupFile);
+    }
+
+    static class BitmapWorkerTask extends AsyncTask<Jid, Void, Bitmap> {
+        private final WeakReference<ImageView> imageViewReference;
+        private Jid jid = null;
+        private final int size;
+
+        BitmapWorkerTask(ImageView imageView) {
+            imageViewReference = new WeakReference<>(imageView);
+            DisplayMetrics metrics = imageView.getContext().getResources().getDisplayMetrics();
+            this.size = ((int) (48 * metrics.density));
+        }
+
+        @Override
+        protected Bitmap doInBackground(Jid... params) {
+            this.jid = params[0];
+            return AvatarService.get(this.jid, size);
+        }
+
+        @Override
+        protected void onPostExecute(Bitmap bitmap) {
+            if (bitmap != null && !isCancelled()) {
+                final ImageView imageView = imageViewReference.get();
+                if (imageView != null) {
+                    imageView.setImageBitmap(bitmap);
+                    imageView.setBackgroundColor(0x00000000);
+                }
+            }
+        }
+    }
+
+    private void loadAvatar(Jid jid, ImageView imageView) {
+        if (cancelPotentialWork(jid, imageView)) {
+            imageView.setBackgroundColor(UIHelper.getColorForName(jid.asBareJid().toString()));
+            imageView.setImageDrawable(null);
+            final BitmapWorkerTask task = new BitmapWorkerTask(imageView);
+            final AsyncDrawable asyncDrawable = new AsyncDrawable(imageView.getContext().getResources(), null, task);
+            imageView.setImageDrawable(asyncDrawable);
+            try {
+                task.execute(jid);
+            } catch (final RejectedExecutionException ignored) {
+            }
+        }
+    }
+
+    private static boolean cancelPotentialWork(Jid jid, ImageView imageView) {
+        final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);
+
+        if (bitmapWorkerTask != null) {
+            final Jid oldJid = bitmapWorkerTask.jid;
+            if (oldJid == null || jid != oldJid) {
+                bitmapWorkerTask.cancel(true);
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static BitmapWorkerTask getBitmapWorkerTask(ImageView imageView) {
+        if (imageView != null) {
+            final Drawable drawable = imageView.getDrawable();
+            if (drawable instanceof AsyncDrawable) {
+                final AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;
+                return asyncDrawable.getBitmapWorkerTask();
+            }
+        }
+        return null;
+    }
+
+    static class AsyncDrawable extends BitmapDrawable {
+        private final WeakReference<BitmapWorkerTask> bitmapWorkerTaskReference;
+
+        AsyncDrawable(Resources res, Bitmap bitmap, BitmapWorkerTask bitmapWorkerTask) {
+            super(res, bitmap);
+            bitmapWorkerTaskReference = new WeakReference<>(bitmapWorkerTask);
+        }
+
+        BitmapWorkerTask getBitmapWorkerTask() {
+            return bitmapWorkerTaskReference.get();
+        }
+    }
+}
\ No newline at end of file