mirror of
https://github.com/etesync/android
synced 2025-01-04 21:01:05 +00:00
370 lines
16 KiB
Java
370 lines
16 KiB
Java
/*
|
||
* Copyright © 2013 – 2015 Ricki Hirner (bitfire web engineering).
|
||
* All rights reserved. This program and the accompanying materials
|
||
* are made available under the terms of the GNU Public License v3.0
|
||
* which accompanies this distribution, and is available at
|
||
* http://www.gnu.org/licenses/gpl.html
|
||
*/
|
||
package at.bitfire.davdroid;
|
||
|
||
import android.accounts.Account;
|
||
import android.accounts.AccountManager;
|
||
import android.app.Notification;
|
||
import android.app.NotificationManager;
|
||
import android.content.ContentProviderClient;
|
||
import android.content.ContentResolver;
|
||
import android.content.ContentUris;
|
||
import android.content.ContentValues;
|
||
import android.content.Context;
|
||
import android.content.PeriodicSync;
|
||
import android.database.Cursor;
|
||
import android.database.sqlite.SQLiteDatabase;
|
||
import android.net.Uri;
|
||
import android.os.Bundle;
|
||
import android.provider.CalendarContract;
|
||
import android.provider.CalendarContract.Calendars;
|
||
import android.provider.ContactsContract;
|
||
import android.support.annotation.NonNull;
|
||
import android.support.v7.app.NotificationCompat;
|
||
import android.text.TextUtils;
|
||
|
||
import java.lang.reflect.Method;
|
||
import java.net.URI;
|
||
import java.net.URISyntaxException;
|
||
import java.util.HashSet;
|
||
import java.util.List;
|
||
import java.util.Set;
|
||
import java.util.logging.Level;
|
||
|
||
import at.bitfire.davdroid.model.ServiceDB;
|
||
import at.bitfire.davdroid.model.ServiceDB.*;
|
||
import at.bitfire.davdroid.resource.LocalAddressBook;
|
||
import at.bitfire.davdroid.resource.LocalCalendar;
|
||
import at.bitfire.davdroid.resource.LocalTaskList;
|
||
import at.bitfire.ical4android.CalendarStorageException;
|
||
import at.bitfire.ical4android.TaskProvider;
|
||
import at.bitfire.vcard4android.ContactsStorageException;
|
||
import lombok.Cleanup;
|
||
import okhttp3.HttpUrl;
|
||
|
||
public class AccountSettings {
|
||
private final static int CURRENT_VERSION = 3;
|
||
private final static String
|
||
KEY_SETTINGS_VERSION = "version",
|
||
|
||
KEY_USERNAME = "user_name",
|
||
KEY_AUTH_PREEMPTIVE = "auth_preemptive";
|
||
|
||
/** Time range limitation to the past [in days]
|
||
value = null default value (DEFAULT_TIME_RANGE_PAST_DAYS)
|
||
< 0 (-1) no limit
|
||
>= 0 entries more than n days in the past won't be synchronized
|
||
*/
|
||
private final static String KEY_TIME_RANGE_PAST_DAYS = "time_range_past_days";
|
||
private final static int DEFAULT_TIME_RANGE_PAST_DAYS = 90;
|
||
|
||
public final static long SYNC_INTERVAL_MANUALLY = -1;
|
||
|
||
final Context context;
|
||
final AccountManager accountManager;
|
||
final Account account;
|
||
|
||
|
||
public AccountSettings(@NonNull Context context, @NonNull Account account) {
|
||
this.context = context;
|
||
this.account = account;
|
||
|
||
accountManager = AccountManager.get(context);
|
||
|
||
synchronized(AccountSettings.class) {
|
||
int version = 0;
|
||
try {
|
||
version = Integer.parseInt(accountManager.getUserData(account, KEY_SETTINGS_VERSION));
|
||
} catch(NumberFormatException ignored) {
|
||
}
|
||
App.log.info("Account " + account.name + " has version " + version + ", current version: " + CURRENT_VERSION);
|
||
|
||
if (version < CURRENT_VERSION) {
|
||
Notification notify = new NotificationCompat.Builder(context)
|
||
.setSmallIcon(R.drawable.ic_launcher)
|
||
.setContentTitle(context.getString(R.string.settings_version_update))
|
||
.setContentText(context.getString(R.string.settings_version_update_warning))
|
||
.setCategory(NotificationCompat.CATEGORY_SYSTEM)
|
||
.setPriority(NotificationCompat.PRIORITY_HIGH)
|
||
.setLocalOnly(true)
|
||
.build();
|
||
NotificationManager nm = (NotificationManager)context.getSystemService(Context.NOTIFICATION_SERVICE);
|
||
nm.notify(Constants.NOTIFICATION_ACCOUNT_SETTINGS_UPDATED, notify);
|
||
|
||
update(version);
|
||
}
|
||
}
|
||
}
|
||
|
||
public static Bundle initialUserData(String userName, boolean preemptive) {
|
||
Bundle bundle = new Bundle();
|
||
bundle.putString(KEY_SETTINGS_VERSION, String.valueOf(CURRENT_VERSION));
|
||
bundle.putString(KEY_USERNAME, userName);
|
||
bundle.putString(KEY_AUTH_PREEMPTIVE, Boolean.toString(preemptive));
|
||
return bundle;
|
||
}
|
||
|
||
|
||
// authentication settings
|
||
|
||
public String username() { return accountManager.getUserData(account, KEY_USERNAME); }
|
||
public void username(@NonNull String userName) { accountManager.setUserData(account, KEY_USERNAME, userName); }
|
||
|
||
public String password() { return accountManager.getPassword(account); }
|
||
public void password(@NonNull String password) { accountManager.setPassword(account, password); }
|
||
|
||
public boolean preemptiveAuth() { return Boolean.parseBoolean(accountManager.getUserData(account, KEY_AUTH_PREEMPTIVE)); }
|
||
public void preemptiveAuth(boolean preemptive) { accountManager.setUserData(account, KEY_AUTH_PREEMPTIVE, Boolean.toString(preemptive)); }
|
||
|
||
|
||
// sync. settings
|
||
|
||
public Long getSyncInterval(@NonNull String authority) {
|
||
if (ContentResolver.getIsSyncable(account, authority) <= 0)
|
||
return null;
|
||
|
||
if (ContentResolver.getSyncAutomatically(account, authority)) {
|
||
List<PeriodicSync> syncs = ContentResolver.getPeriodicSyncs(account, authority);
|
||
if (syncs.isEmpty())
|
||
return SYNC_INTERVAL_MANUALLY;
|
||
else
|
||
return syncs.get(0).period;
|
||
} else
|
||
return SYNC_INTERVAL_MANUALLY;
|
||
}
|
||
|
||
public void setSyncInterval(@NonNull String authority, long seconds) {
|
||
if (seconds == SYNC_INTERVAL_MANUALLY) {
|
||
ContentResolver.setSyncAutomatically(account, authority, false);
|
||
} else {
|
||
ContentResolver.setSyncAutomatically(account, authority, true);
|
||
ContentResolver.addPeriodicSync(account, authority, new Bundle(), seconds);
|
||
}
|
||
}
|
||
|
||
public Integer getTimeRangePastDays() {
|
||
String strDays = accountManager.getUserData(account, KEY_TIME_RANGE_PAST_DAYS);
|
||
if (strDays != null) {
|
||
int days = Integer.valueOf(strDays);
|
||
return days < 0 ? null : days;
|
||
} else
|
||
return DEFAULT_TIME_RANGE_PAST_DAYS;
|
||
}
|
||
|
||
public void setTimeRangePastDays(Integer days) {
|
||
accountManager.setUserData(account, KEY_TIME_RANGE_PAST_DAYS, String.valueOf(days == null ? -1 : days));
|
||
}
|
||
|
||
|
||
// update from previous account settings
|
||
|
||
private void update(int fromVersion) {
|
||
for (int toVersion = fromVersion + 1; toVersion <= CURRENT_VERSION; toVersion++) {
|
||
App.log.info("Updating account " + account.name + " from version " + fromVersion + " to " + toVersion);
|
||
try {
|
||
Method updateProc = getClass().getDeclaredMethod("update_" + fromVersion + "_" + toVersion);
|
||
updateProc.invoke(this);
|
||
} catch (Exception e) {
|
||
App.log.log(Level.SEVERE, "Couldn't update account settings", e);
|
||
}
|
||
fromVersion = toVersion;
|
||
}
|
||
}
|
||
|
||
@SuppressWarnings({ "Recycle", "unused" })
|
||
private void update_0_1() throws URISyntaxException {
|
||
String v0_principalURL = accountManager.getUserData(account, "principal_url"),
|
||
v0_addressBookPath = accountManager.getUserData(account, "addressbook_path");
|
||
App.log.fine("Old principal URL = " + v0_principalURL);
|
||
App.log.fine("Old address book path = " + v0_addressBookPath);
|
||
|
||
URI principalURI = new URI(v0_principalURL);
|
||
|
||
// update address book
|
||
if (v0_addressBookPath != null) {
|
||
String addressBookURL = principalURI.resolve(v0_addressBookPath).toASCIIString();
|
||
App.log.fine("New address book URL = " + addressBookURL);
|
||
accountManager.setUserData(account, "addressbook_url", addressBookURL);
|
||
}
|
||
|
||
// update calendars
|
||
ContentResolver resolver = context.getContentResolver();
|
||
Uri calendars = Calendars.CONTENT_URI.buildUpon()
|
||
.appendQueryParameter(Calendars.ACCOUNT_NAME, account.name)
|
||
.appendQueryParameter(Calendars.ACCOUNT_TYPE, account.type)
|
||
.appendQueryParameter(CalendarContract.CALLER_IS_SYNCADAPTER, "true").build();
|
||
@Cleanup Cursor cursor = resolver.query(calendars, new String[] { Calendars._ID, Calendars.NAME }, null, null, null);
|
||
while (cursor != null && cursor.moveToNext()) {
|
||
int id = cursor.getInt(0);
|
||
String v0_path = cursor.getString(1),
|
||
v1_url = principalURI.resolve(v0_path).toASCIIString();
|
||
App.log.fine("Updating calendar #" + id + " name: " + v0_path + " -> " + v1_url);
|
||
Uri calendar = ContentUris.appendId(Calendars.CONTENT_URI.buildUpon()
|
||
.appendQueryParameter(Calendars.ACCOUNT_NAME, account.name)
|
||
.appendQueryParameter(Calendars.ACCOUNT_TYPE, account.type)
|
||
.appendQueryParameter(CalendarContract.CALLER_IS_SYNCADAPTER, "true"), id).build();
|
||
ContentValues newValues = new ContentValues(1);
|
||
newValues.put(Calendars.NAME, v1_url);
|
||
if (resolver.update(calendar, newValues, null, null) != 1)
|
||
App.log.fine("Number of modified calendars != 1");
|
||
}
|
||
|
||
accountManager.setUserData(account, "principal_url", null);
|
||
accountManager.setUserData(account, "addressbook_path", null);
|
||
|
||
accountManager.setUserData(account, KEY_SETTINGS_VERSION, "1");
|
||
}
|
||
|
||
@SuppressWarnings({ "Recycle", "unused" })
|
||
private void update_1_2() throws ContactsStorageException {
|
||
/* - KEY_ADDRESSBOOK_URL ("addressbook_url"),
|
||
- KEY_ADDRESSBOOK_CTAG ("addressbook_ctag"),
|
||
- KEY_ADDRESSBOOK_VCARD_VERSION ("addressbook_vcard_version") are not used anymore (now stored in ContactsContract.SyncState)
|
||
- KEY_LAST_ANDROID_VERSION ("last_android_version") has been added
|
||
*/
|
||
|
||
// move previous address book info to ContactsContract.SyncState
|
||
@Cleanup("release") ContentProviderClient provider = context.getContentResolver().acquireContentProviderClient(ContactsContract.AUTHORITY);
|
||
if (provider == null)
|
||
throw new ContactsStorageException("Couldn't access Contacts provider");
|
||
|
||
LocalAddressBook addr = new LocalAddressBook(account, provider);
|
||
|
||
// until now, ContactsContract.Settings.UNGROUPED_VISIBLE was not set explicitly
|
||
ContentValues values = new ContentValues();
|
||
values.put(ContactsContract.Settings.UNGROUPED_VISIBLE, 1);
|
||
addr.updateSettings(values);
|
||
|
||
String url = accountManager.getUserData(account, "addressbook_url");
|
||
if (!TextUtils.isEmpty(url))
|
||
addr.setURL(url);
|
||
accountManager.setUserData(account, "addressbook_url", null);
|
||
|
||
String cTag = accountManager.getUserData(account, "addressbook_ctag");
|
||
if (!TextUtils.isEmpty(cTag))
|
||
addr.setCTag(cTag);
|
||
accountManager.setUserData(account, "addressbook_ctag", null);
|
||
|
||
accountManager.setUserData(account, KEY_SETTINGS_VERSION, "2");
|
||
}
|
||
|
||
@SuppressWarnings({ "Recycle", "unused" })
|
||
private void update_2_3() {
|
||
// Don't show a warning for Android updates anymore
|
||
accountManager.setUserData(account, "last_android_version", null);
|
||
|
||
ServiceDB.OpenHelper dbHelper = new ServiceDB.OpenHelper(context);
|
||
try {
|
||
SQLiteDatabase db = dbHelper.getWritableDatabase();
|
||
// we have to create the WebDAV Service database only from the old address book, calendar and task list URLs
|
||
|
||
// CardDAV: migrate address books
|
||
ContentProviderClient client = context.getContentResolver().acquireContentProviderClient(ContactsContract.AUTHORITY);
|
||
if (client != null)
|
||
try {
|
||
LocalAddressBook addrBook = new LocalAddressBook(account, client);
|
||
String url = addrBook.getURL();
|
||
if (url != null) {
|
||
App.log.fine("Migrating address book " + url);
|
||
|
||
// insert CardDAV service
|
||
ContentValues values = new ContentValues();
|
||
values.put(Services.ACCOUNT_NAME, account.name);
|
||
values.put(Services.SERVICE, Services.SERVICE_CARDDAV);
|
||
long service = db.insert(Services._TABLE, null, values);
|
||
|
||
// insert address book
|
||
values.clear();
|
||
values.put(Collections.SERVICE_ID, service);
|
||
values.put(Collections.URL, url);
|
||
values.put(Collections.SYNC, 1);
|
||
db.insert(Collections._TABLE, null, values);
|
||
|
||
// insert home set
|
||
HttpUrl homeSet = HttpUrl.parse(url).resolve("../");
|
||
values.clear();
|
||
values.put(HomeSets.SERVICE_ID, service);
|
||
values.put(HomeSets.URL, homeSet.toString());
|
||
db.insert(HomeSets._TABLE, null, values);
|
||
}
|
||
} catch (ContactsStorageException e) {
|
||
App.log.log(Level.SEVERE, "Couldn't migrate address book", e);
|
||
} finally {
|
||
client.release();
|
||
}
|
||
|
||
// CalDAV: migrate calendars + task lists
|
||
Set<String> collections = new HashSet<>();
|
||
Set<HttpUrl> homeSets = new HashSet<>();
|
||
|
||
client = context.getContentResolver().acquireContentProviderClient(CalendarContract.AUTHORITY);
|
||
if (client != null)
|
||
try {
|
||
LocalCalendar calendars[] = (LocalCalendar[])LocalCalendar.find(account, client, LocalCalendar.Factory.INSTANCE, null, null);
|
||
for (LocalCalendar calendar : calendars) {
|
||
String url = calendar.getName();
|
||
App.log.fine("Migrating calendar " + url);
|
||
collections.add(url);
|
||
homeSets.add(HttpUrl.parse(url).resolve("../"));
|
||
}
|
||
} catch (CalendarStorageException e) {
|
||
App.log.log(Level.SEVERE, "Couldn't migrate calendars", e);
|
||
} finally {
|
||
client.release();
|
||
}
|
||
|
||
TaskProvider provider = LocalTaskList.acquireTaskProvider(context.getContentResolver());
|
||
if (provider != null)
|
||
try {
|
||
LocalTaskList[] taskLists = (LocalTaskList[])LocalTaskList.find(account, provider, LocalTaskList.Factory.INSTANCE, null, null);
|
||
for (LocalTaskList taskList : taskLists) {
|
||
String url = taskList.getSyncId();
|
||
App.log.fine("Migrating task list " + url);
|
||
collections.add(url);
|
||
homeSets.add(HttpUrl.parse(url).resolve("../"));
|
||
}
|
||
} catch (CalendarStorageException e) {
|
||
App.log.log(Level.SEVERE, "Couldn't migrate task lists", e);
|
||
} finally {
|
||
provider.close();
|
||
}
|
||
|
||
if (!collections.isEmpty()) {
|
||
// insert CalDAV service
|
||
ContentValues values = new ContentValues();
|
||
values.put(Services.ACCOUNT_NAME, account.name);
|
||
values.put(Services.SERVICE, Services.SERVICE_CALDAV);
|
||
long service = db.insert(Services._TABLE, null, values);
|
||
|
||
// insert collections
|
||
for (String url : collections) {
|
||
values.clear();
|
||
values.put(Collections.SERVICE_ID, service);
|
||
values.put(Collections.URL, url);
|
||
values.put(Collections.SYNC, 1);
|
||
db.insert(Collections._TABLE, null, values);
|
||
}
|
||
|
||
// insert home sets
|
||
for (HttpUrl homeSet : homeSets) {
|
||
values.clear();
|
||
values.put(HomeSets.SERVICE_ID, service);
|
||
values.put(HomeSets.URL, homeSet.toString());
|
||
db.insert(HomeSets._TABLE, null, values);
|
||
}
|
||
}
|
||
|
||
} finally {
|
||
dbHelper.close();
|
||
}
|
||
|
||
accountManager.setUserData(account, KEY_SETTINGS_VERSION, "3");
|
||
}
|
||
|
||
}
|