git.ipfire.org Git - thirdparty/strongswan.git/blob

   1 /*
   2  * Copyright (C) 2012-2015 Tobias Brunner
   3  * HSR Hochschule fuer Technik Rapperswil
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  */
  15
  16 package org.strongswan.android.ui;
  17
  18 import android.content.Context;
  19 import android.os.Bundle;
  20 import android.support.v4.app.ListFragment;
  21 import android.support.v4.app.LoaderManager;
  22 import android.support.v4.app.LoaderManager.LoaderCallbacks;
  23 import android.support.v4.content.AsyncTaskLoader;
  24 import android.support.v4.content.Loader;
  25 import android.text.TextUtils;
  26 import android.view.Menu;
  27 import android.view.MenuInflater;
  28 import android.view.MenuItem;
  29 import android.view.View;
  30 import android.widget.ListView;
  31 import android.widget.SearchView;
  32 import android.widget.SearchView.OnQueryTextListener;
  33
  34 import org.strongswan.android.R;
  35 import org.strongswan.android.logic.TrustedCertificateManager;
  36 import org.strongswan.android.logic.TrustedCertificateManager.TrustedCertificateSource;
  37 import org.strongswan.android.security.TrustedCertificateEntry;
  38 import org.strongswan.android.ui.adapter.TrustedCertificateAdapter;
  39
  40 import java.security.cert.X509Certificate;
  41 import java.util.ArrayList;
  42 import java.util.Collections;
  43 import java.util.Hashtable;
  44 import java.util.List;
  45 import java.util.Map.Entry;
  46 import java.util.Observable;
  47 import java.util.Observer;
  48
  49 public class TrustedCertificateListFragment extends ListFragment implements LoaderCallbacks<List<TrustedCertificateEntry>>, OnQueryTextListener
  50 {
  51         public static final String EXTRA_CERTIFICATE_SOURCE = "certificate_source";
  52         private OnTrustedCertificateSelectedListener mListener;
  53         private TrustedCertificateAdapter mAdapter;
  54         private TrustedCertificateSource mSource = TrustedCertificateSource.SYSTEM;
  55
  56         /**
  57          * The activity containing this fragment should implement this interface
  58          */
  59         public interface OnTrustedCertificateSelectedListener
  60         {
  61                 public void onTrustedCertificateSelected(TrustedCertificateEntry selected);
  62         }
  63
  64         @Override
  65         public void onActivityCreated(Bundle savedInstanceState)
  66         {
  67                 super.onActivityCreated(savedInstanceState);
  68                 setHasOptionsMenu(true);
  69
  70                 setEmptyText(getString(R.string.no_certificates));
  71
  72                 mAdapter = new TrustedCertificateAdapter(getActivity());
  73                 setListAdapter(mAdapter);
  74
  75                 setListShown(false);
  76
  77                 Bundle arguments = getArguments();
  78                 if (arguments != null)
  79                 {
  80                         mSource = (TrustedCertificateSource)arguments.getSerializable(EXTRA_CERTIFICATE_SOURCE);
  81                 }
  82
  83                 LoaderManager.getInstance(this).initLoader(0, null, this);
  84         }
  85
  86         @Override
  87         public void onDestroy()
  88         {
  89                 super.onDestroy();
  90         }
  91
  92         @Override
  93         public void onAttach(Context context)
  94         {
  95                 super.onAttach(context);
  96
  97                 if (context instanceof OnTrustedCertificateSelectedListener)
  98                 {
  99                         mListener = (OnTrustedCertificateSelectedListener)context;
 100                 }
 101         }
 102
 103         @Override
 104         public void onCreateOptionsMenu(Menu menu, MenuInflater inflater)
 105         {
 106                 MenuItem item = menu.add(R.string.search);
 107                 item.setIcon(android.R.drawable.ic_menu_search);
 108                 item.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
 109
 110                 SearchView sv = new SearchView(getActivity());
 111                 sv.setOnQueryTextListener(this);
 112                 item.setActionView(sv);
 113         }
 114
 115         @Override
 116         public boolean onQueryTextSubmit(String query)
 117         {       /* already handled when the text changes */
 118                 return true;
 119         }
 120
 121         @Override
 122         public boolean onQueryTextChange(String newText)
 123         {
 124                 String search = TextUtils.isEmpty(newText) ? null : newText;
 125                 mAdapter.getFilter().filter(search);
 126                 return true;
 127         }
 128
 129         @Override
 130         public Loader<List<TrustedCertificateEntry>> onCreateLoader(int id, Bundle args)
 131         {       /* we don't need the id as we have only one loader */
 132                 return new CertificateListLoader(getActivity(), mSource);
 133         }
 134
 135         @Override
 136         public void onLoadFinished(Loader<List<TrustedCertificateEntry>> loader, List<TrustedCertificateEntry> data)
 137         {
 138                 mAdapter.setData(data);
 139
 140                 if (isResumed())
 141                 {
 142                         setListShown(true);
 143                 }
 144                 else
 145                 {
 146                         setListShownNoAnimation(true);
 147                 }
 148         }
 149
 150         @Override
 151         public void onLoaderReset(Loader<List<TrustedCertificateEntry>> loader)
 152         {
 153                 mAdapter.setData(null);
 154         }
 155
 156         @Override
 157         public void onListItemClick(ListView l, View v, int position, long id)
 158         {
 159                 if (mListener != null)
 160                 {
 161                         mListener.onTrustedCertificateSelected(mAdapter.getItem(position));
 162                 }
 163         }
 164
 165         public static class CertificateListLoader extends AsyncTaskLoader<List<TrustedCertificateEntry>>
 166         {
 167                 private List<TrustedCertificateEntry> mData;
 168                 private final TrustedCertificateSource mSource;
 169                 private TrustedCertificateManagerObserver mObserver;
 170
 171                 public CertificateListLoader(Context context, TrustedCertificateSource source)
 172                 {
 173                         super(context);
 174                         mSource = source;
 175                 }
 176
 177                 @Override
 178                 public List<TrustedCertificateEntry> loadInBackground()
 179                 {
 180                         TrustedCertificateManager certman = TrustedCertificateManager.getInstance().load();
 181                         Hashtable<String, X509Certificate> certificates = certman.getCACertificates(mSource);
 182                         List<TrustedCertificateEntry> selected;
 183
 184                         selected = new ArrayList<TrustedCertificateEntry>();
 185                         for (Entry<String, X509Certificate> entry : certificates.entrySet())
 186                         {
 187                                 selected.add(new TrustedCertificateEntry(entry.getKey(), entry.getValue()));
 188                         }
 189                         Collections.sort(selected);
 190                         return selected;
 191                 }
 192
 193                 @Override
 194                 protected void onStartLoading()
 195                 {
 196                         if (mData != null)
 197                         {       /* if we have data ready, deliver it directly */
 198                                 deliverResult(mData);
 199                         }
 200                         if (takeContentChanged() || mData == null)
 201                         {
 202                                 forceLoad();
 203                         }
 204                 }
 205
 206                 @Override
 207                 public void deliverResult(List<TrustedCertificateEntry> data)
 208                 {
 209                         if (isReset())
 210                         {
 211                                 return;
 212                         }
 213                         mData = data;
 214                         if (isStarted())
 215                         {       /* if it is started we deliver the data directly,
 216                                  * otherwise this is handled in onStartLoading */
 217                                 if (mObserver == null)
 218                                 {
 219                                         mObserver = new TrustedCertificateManagerObserver();
 220                                         TrustedCertificateManager.getInstance().addObserver(mObserver);
 221                                 }
 222                                 super.deliverResult(data);
 223                         }
 224                 }
 225
 226                 @Override
 227                 protected void onReset()
 228                 {
 229                         if (mObserver != null)
 230                         {
 231                                 TrustedCertificateManager.getInstance().deleteObserver(mObserver);
 232                                 mObserver = null;
 233                         }
 234                         mData = null;
 235                         super.onReset();
 236                 }
 237
 238                 @Override
 239                 protected void onAbandon()
 240                 {
 241                         if (mObserver != null)
 242                         {
 243                                 TrustedCertificateManager.getInstance().deleteObserver(mObserver);
 244                                 mObserver = null;
 245                         }
 246                 }
 247
 248                 private class TrustedCertificateManagerObserver implements Observer
 249                 {
 250                         private ForceLoadContentObserver mContentObserver = new ForceLoadContentObserver();
 251
 252                         @Override
 253                         public void update(Observable observable, Object data)
 254                         {
 255                                 mContentObserver.onChange(false);
 256                         }
 257                 }
 258         }
 259 }