Pileus Git - ~andy/freeotp/blob - src/org/fedorahosted/freeotp/TokenAdapter.java

   1 /*
   2  * FreeOTP
   3  *
   4  * Authors: Nathaniel McCallum <npmccallum@redhat.com>
   5  *
   6  * Copyright (C) 2013  Nathaniel McCallum, Red Hat
   7  * see file 'COPYING' for use and warranty information
   8  *
   9  * This program is free software you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation, either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 package org.fedorahosted.freeotp;
  24
  25 import java.util.ArrayList;
  26 import java.util.Collections;
  27 import java.util.Comparator;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31
  32 import org.fedorahosted.freeotp.Token.TokenUriInvalidException;
  33
  34 import android.app.AlertDialog;
  35 import android.content.Context;
  36 import android.content.DialogInterface;
  37 import android.os.Handler;
  38 import android.os.Message;
  39 import android.view.View;
  40 import android.view.View.OnClickListener;
  41 import android.view.ViewGroup;
  42 import android.widget.BaseAdapter;
  43 import android.widget.ImageButton;
  44 import android.widget.ProgressBar;
  45 import android.widget.TextView;
  46
  47 public class TokenAdapter extends BaseAdapter {
  48         private static class Ticker extends Handler {
  49                 private static interface OnTickListener {
  50                         public void tick(ProgressBar pb);
  51                 }
  52
  53                 private final Map<ProgressBar, OnTickListener> map = new HashMap<ProgressBar, OnTickListener>();
  54
  55                 @Override
  56                 public void handleMessage(Message msg) {
  57                         for (ProgressBar pb : map.keySet())
  58                                 map.get(pb).tick(pb);
  59
  60                         sendEmptyMessageDelayed(0, 200);
  61                 }
  62
  63                 public void set(ProgressBar pb, OnTickListener otl) {
  64                         map.put(pb, otl);
  65                 }
  66         }
  67
  68         private final List<Token> tokens = new ArrayList<Token>();
  69         private final Ticker ticker = new Ticker();
  70
  71         private void sort() {
  72                 Collections.sort(tokens, new Comparator<Token>() {
  73                         @Override
  74                         public int compare(Token lhs, Token rhs) {
  75                                 return lhs.getTitle().compareTo(rhs.getTitle());
  76                         }
  77                 });
  78         }
  79
  80         public TokenAdapter(Context ctx) {
  81                 tokens.addAll(Token.getTokens(ctx));
  82                 ticker.sendEmptyMessageDelayed(0, 200);
  83                 sort();
  84         }
  85
  86         @Override
  87         public int getCount() {
  88                 return tokens.size();
  89         }
  90
  91         @Override
  92         public Token getItem(int position) {
  93                 return tokens.get(position);
  94         }
  95
  96         @Override
  97         public long getItemId(int position) {
  98                 return position;
  99         }
 100
 101         @Override
 102         public View getView(int position, View convertView, ViewGroup parent) {
 103                 final Context ctx = parent.getContext();
 104
 105                 if (convertView == null) {
 106                         switch (getItem(position).getType()) {
 107                         case HOTP:
 108                                 convertView = View.inflate(ctx, R.layout.hotp, null);
 109                                 break;
 110
 111                         case TOTP:
 112                                 convertView = View.inflate(ctx, R.layout.totp, null);
 113                                 break;
 114                         }
 115                 }
 116
 117                 final Token item = getItem(position);
 118                 final TextView code = (TextView) convertView.findViewById(R.id.code);
 119                 final TextView title = (TextView) convertView.findViewById(R.id.title);
 120                 final ImageButton ib = (ImageButton) convertView.findViewById(R.id.button);
 121
 122                 code.setText(item.getCurrentTokenValue(ctx, false));
 123                 title.setText(item.getTitle());
 124
 125                 ib.setOnClickListener(new OnClickListener() {
 126                         @Override
 127                         public void onClick(View v) {
 128                                 String delmsg = ctx.getString(R.string.delete_message);
 129
 130                                 AlertDialog ad = new AlertDialog.Builder(ctx)
 131                                 .setTitle("Delete")
 132                                 .setMessage(delmsg + item.getTitle())
 133                                 .setIcon(android.R.drawable.ic_delete)
 134                                 .setPositiveButton(R.string.delete,
 135                                                 new DialogInterface.OnClickListener() {
 136                                                         @Override
 137                                                         public void onClick(DialogInterface dialog, int which) {
 138                                                                 tokens.remove(tokens.indexOf(item));
 139                                                                 item.remove(ctx);
 140                                                                 notifyDataSetChanged();
 141                                                                 dialog.dismiss();
 142                                                         }
 143
 144                                                 })
 145                                 .setNegativeButton(android.R.string.cancel,
 146                                                 new DialogInterface.OnClickListener() {
 147                                                         @Override
 148                                                         public void onClick(DialogInterface dialog, int which) {
 149                                                                 dialog.cancel();
 150                                                         }
 151                                                 }).create();
 152                                 ad.show();
 153                         }
 154                 });
 155
 156                 switch (getItem(position).getType()) {
 157                 case HOTP:
 158                         ImageButton hotp = (ImageButton) convertView.findViewById(R.id.hotpButton);
 159                         hotp.setOnClickListener(new OnClickListener() {
 160                                 @Override
 161                                 public void onClick(View v) {
 162                                         code.setText(item.getCurrentTokenValue(ctx, true));
 163                                 }
 164                         });
 165                         break;
 166
 167                 case TOTP:
 168                         ProgressBar pb = (ProgressBar) convertView.findViewById(R.id.totpProgressBar);
 169                         ticker.set(pb, new Ticker.OnTickListener() {
 170                                 @Override
 171                                 public void tick(ProgressBar pb) {
 172                                         int max = pb.getMax();
 173                                         int pro = item.getProgress();
 174                                         pb.setProgress(max - pro);
 175                                         if (pro < max / 20 || pro > max / 20 * 19)
 176                                                 code.setText(item.getCurrentTokenValue(ctx, false));
 177                                 }
 178                         });
 179                         break;
 180                 }
 181
 182                 return convertView;
 183         }
 184
 185         @Override
 186         public int getViewTypeCount() {
 187                 return 2;
 188         }
 189
 190         @Override
 191         public int getItemViewType(int position) {
 192                 switch (getItem(position).getType()) {
 193                 case HOTP:
 194                         return 0;
 195                 case TOTP:
 196                         return 1;
 197                 default:
 198                         return -1;
 199                 }
 200         }
 201
 202         public void add(Context ctx, String uri) throws TokenUriInvalidException {
 203                 Token t = new Token(uri);
 204                 t.save(ctx);
 205                 tokens.add(t);
 206                 sort();
 207                 notifyDataSetChanged();
 208         }
 209 }