();
25 |
26 | RxAndroidPlugins() {
27 | }
28 |
29 | /**
30 | * Reset any explicit or default-set hooks.
31 | *
32 | * Note: This should only be used for testing purposes.
33 | */
34 | @Beta
35 | public void reset() {
36 | schedulersHook.set(null);
37 | }
38 |
39 | /**
40 | * Retrieves the instance of {@link RxAndroidSchedulersHook} to use based on order of
41 | * precedence as defined in the {@link RxAndroidPlugins} class header.
42 | *
43 | * Override the default by calling {@link #registerSchedulersHook(RxAndroidSchedulersHook)} or by
44 | * setting the property {@code rxandroid.plugin.RxAndroidSchedulersHook.implementation} with the
45 | * full classname to load.
46 | */
47 | public RxAndroidSchedulersHook getSchedulersHook() {
48 | if (schedulersHook.get() == null) {
49 | schedulersHook.compareAndSet(null, RxAndroidSchedulersHook.getDefaultInstance());
50 | // We don't return from here but call get() again in case of thread-race so the winner will
51 | // always get returned.
52 | }
53 | return schedulersHook.get();
54 | }
55 |
56 | /**
57 | * Registers an {@link RxAndroidSchedulersHook} implementation as a global override of any
58 | * injected or default implementations.
59 | *
60 | * @throws IllegalStateException if called more than once or after the default was initialized
61 | * (if usage occurs before trying to register)
62 | */
63 | public void registerSchedulersHook(RxAndroidSchedulersHook impl) {
64 | if (!schedulersHook.compareAndSet(null, impl)) {
65 | throw new IllegalStateException(
66 | "Another strategy was already registered: " + schedulersHook.get());
67 | }
68 | }
69 | }
--------------------------------------------------------------------------------
/src/com/activeandroid/rxschedulers/RxAndroidSchedulersHook.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.rxschedulers;
2 |
3 | import rx.Scheduler;
4 | import rx.functions.Action0;
5 |
6 | public class RxAndroidSchedulersHook {
7 | private static final RxAndroidSchedulersHook DEFAULT_INSTANCE = new RxAndroidSchedulersHook();
8 |
9 | public static RxAndroidSchedulersHook getDefaultInstance() {
10 | return DEFAULT_INSTANCE;
11 | }
12 |
13 | /**
14 | * Scheduler to return from {@link AndroidSchedulers#mainThread()} or {@code null} if default
15 | * should be used.
16 | *
17 | * This instance should be or behave like a stateless singleton.
18 | */
19 | public Scheduler getMainThreadScheduler() {
20 | return null;
21 | }
22 |
23 | /**
24 | * Invoked before the Action is handed over to the scheduler. Can be used for
25 | * wrapping/decorating/logging. The default is just a passthrough.
26 | *
27 | * @param action action to schedule
28 | * @return wrapped action to schedule
29 | */
30 | public Action0 onSchedule(Action0 action) {
31 | return action;
32 | }
33 | }
--------------------------------------------------------------------------------
/src/com/activeandroid/serializer/BigDecimalSerializer.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.serializer;
2 |
3 | import java.math.BigDecimal;
4 |
5 | public final class BigDecimalSerializer extends TypeSerializer {
6 | public Class getDeserializedType() {
7 | return BigDecimal.class;
8 | }
9 |
10 | public Class getSerializedType() {
11 | return String.class;
12 | }
13 |
14 | public String serialize(Object data) {
15 | if (data == null) {
16 | return null;
17 | }
18 |
19 | return ((BigDecimal) data).toString();
20 | }
21 |
22 | public BigDecimal deserialize(Object data) {
23 | if (data == null) {
24 | return null;
25 | }
26 |
27 | return new BigDecimal((String) data);
28 | }
29 | }
--------------------------------------------------------------------------------
/src/com/activeandroid/serializer/CalendarSerializer.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.serializer;
2 |
3 | /*
4 | * Copyright (C) 2010 Michael Pardo
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | import java.util.Calendar;
20 |
21 | public final class CalendarSerializer extends TypeSerializer {
22 | public Class getDeserializedType() {
23 | return Calendar.class;
24 | }
25 |
26 | public Class getSerializedType() {
27 | return long.class;
28 | }
29 |
30 | public Long serialize(Object data) {
31 | return ((Calendar) data).getTimeInMillis();
32 | }
33 |
34 | public Calendar deserialize(Object data) {
35 | Calendar calendar = Calendar.getInstance();
36 | calendar.setTimeInMillis((Long) data);
37 |
38 | return calendar;
39 | }
40 | }
--------------------------------------------------------------------------------
/src/com/activeandroid/serializer/FileSerializer.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.serializer;
2 |
3 | import java.io.File;
4 |
5 | /*
6 | * Copyright (C) 2010 Michael Pardo
7 | *
8 | * Licensed under the Apache License, Version 2.0 (the "License");
9 | * you may not use this file except in compliance with the License.
10 | * You may obtain a copy of the License at
11 | *
12 | * http://www.apache.org/licenses/LICENSE-2.0
13 | *
14 | * Unless required by applicable law or agreed to in writing, software
15 | * distributed under the License is distributed on an "AS IS" BASIS,
16 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 | * See the License for the specific language governing permissions and
18 | * limitations under the License.
19 | */
20 |
21 |
22 | public final class FileSerializer extends TypeSerializer {
23 | public Class getDeserializedType() {
24 | return File.class;
25 | }
26 |
27 | public Class getSerializedType() {
28 | return String.class;
29 | }
30 |
31 | public String serialize(Object data) {
32 | if (data == null) {
33 | return null;
34 | }
35 |
36 | return ((File) data).toString();
37 | }
38 |
39 | public File deserialize(Object data) {
40 | if (data == null) {
41 | return null;
42 | }
43 |
44 | return new File((String) data);
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/src/com/activeandroid/serializer/SqlDateSerializer.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.serializer;
2 |
3 | /*
4 | * Copyright (C) 2010 Michael Pardo
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | import java.sql.Date;
20 |
21 | public final class SqlDateSerializer extends TypeSerializer {
22 | public Class getDeserializedType() {
23 | return Date.class;
24 | }
25 |
26 | public Class getSerializedType() {
27 | return long.class;
28 | }
29 |
30 | public Long serialize(Object data) {
31 | if (data == null) {
32 | return null;
33 | }
34 |
35 | return ((Date) data).getTime();
36 | }
37 |
38 | public Date deserialize(Object data) {
39 | if (data == null) {
40 | return null;
41 | }
42 |
43 | return new Date((Long) data);
44 | }
45 | }
--------------------------------------------------------------------------------
/src/com/activeandroid/serializer/TypeSerializer.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.serializer;
2 |
3 | /*
4 | * Copyright (C) 2010 Michael Pardo
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | public abstract class TypeSerializer {
20 | public abstract Class getDeserializedType();
21 |
22 | public abstract Class getSerializedType();
23 |
24 | public abstract Object serialize(Object data);
25 |
26 | public abstract Object deserialize(Object data);
27 | }
--------------------------------------------------------------------------------
/src/com/activeandroid/serializer/UUIDSerializer.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.serializer;
2 |
3 | import java.util.UUID;
4 |
5 | public final class UUIDSerializer extends TypeSerializer {
6 | public Class getDeserializedType() {
7 | return UUID.class;
8 | }
9 |
10 | public Class getSerializedType() {
11 | return String.class;
12 | }
13 |
14 | public String serialize(Object data) {
15 | if (data == null) {
16 | return null;
17 | }
18 |
19 | return ((UUID) data).toString();
20 | }
21 |
22 | public UUID deserialize(Object data) {
23 | if (data == null) {
24 | return null;
25 | }
26 |
27 | return UUID.fromString((String)data);
28 | }
29 | }
--------------------------------------------------------------------------------
/src/com/activeandroid/serializer/UtilDateSerializer.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.serializer;
2 |
3 | /*
4 | * Copyright (C) 2010 Michael Pardo
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | import java.util.Date;
20 |
21 | public final class UtilDateSerializer extends TypeSerializer {
22 | public Class getDeserializedType() {
23 | return Date.class;
24 | }
25 |
26 | public Class getSerializedType() {
27 | return long.class;
28 | }
29 |
30 | public Long serialize(Object data) {
31 | if (data == null) {
32 | return null;
33 | }
34 |
35 | return ((Date) data).getTime();
36 | }
37 |
38 | public Date deserialize(Object data) {
39 | if (data == null) {
40 | return null;
41 | }
42 |
43 | return new Date((Long) data);
44 | }
45 | }
--------------------------------------------------------------------------------
/src/com/activeandroid/sqlbrite/BackpressureBufferLastOperator.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2015 Square, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.activeandroid.sqlbrite;
17 |
18 | import rx.Observable.Operator;
19 | import rx.Producer;
20 | import rx.Subscriber;
21 |
22 | /** An operator which keeps the last emitted instance when backpressure has been applied. */
23 | final class BackpressureBufferLastOperator implements Operator {
24 | static final Operator instance = new BackpressureBufferLastOperator<>();
25 |
26 | static Operator instance() {
27 | //noinspection unchecked
28 | return (Operator) instance;
29 | }
30 |
31 | private BackpressureBufferLastOperator() {
32 | }
33 |
34 | @Override public Subscriber call(final Subscriber child) {
35 | BufferLastSubscriber parent = new BufferLastSubscriber<>(child);
36 | child.add(parent);
37 | child.setProducer(parent.producer);
38 | return parent;
39 | }
40 |
41 | static final class BufferLastSubscriber extends Subscriber {
42 | private static final Object NONE = new Object();
43 |
44 | private final Subscriber child;
45 |
46 | private Object last = NONE; // Guarded by 'this'.
47 | private long requested; // Guarded by 'this'. Starts at zero.
48 |
49 | final Producer producer = new Producer() {
50 | @Override public void request(long n) {
51 | if (n < 0) {
52 | throw new IllegalArgumentException("requested " + n + " < 0");
53 | }
54 | if (n == 0) {
55 | return;
56 | }
57 |
58 | Object candidate;
59 | synchronized (BufferLastSubscriber.this) {
60 | candidate = last;
61 |
62 | long currentRequested = requested;
63 | if (Long.MAX_VALUE - n <= currentRequested) {
64 | requested = Long.MAX_VALUE;
65 | } else {
66 | if (candidate != NONE) {
67 | n--; // Decrement since we will be emitting a value.
68 | }
69 | requested = currentRequested + n;
70 | }
71 | }
72 |
73 | // Only emit if the value is not the explicit NONE marker.
74 | if (candidate != NONE) {
75 | //noinspection unchecked
76 | child.onNext((T) candidate);
77 | }
78 | }
79 | };
80 |
81 | public BufferLastSubscriber(Subscriber child) {
82 | this.child = child;
83 | }
84 |
85 | @Override public void onNext(T t) {
86 | boolean emit = false;
87 | synchronized (this) {
88 | long currentRequested = requested;
89 | if (currentRequested == Long.MAX_VALUE) {
90 | // No need to decrement when the firehose is open.
91 | emit = true;
92 | } else if (currentRequested > 0) {
93 | requested = currentRequested - 1;
94 | emit = true;
95 | } else {
96 | last = t; // Not emitting, store for later.
97 | }
98 | }
99 |
100 | if (emit) {
101 | child.onNext(t);
102 | }
103 | }
104 |
105 | @Override public void onStart() {
106 | request(Long.MAX_VALUE);
107 | }
108 |
109 | @Override public void onCompleted() {
110 | child.onCompleted();
111 | }
112 |
113 | @Override public void onError(Throwable e) {
114 | child.onError(e);
115 | }
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/src/com/activeandroid/sqlbrite/BriteContentResolver.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2015 Square, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.activeandroid.sqlbrite;
17 |
18 | import android.content.ContentResolver;
19 | import android.database.ContentObserver;
20 | import android.database.Cursor;
21 | import android.net.Uri;
22 | import android.os.Handler;
23 | import android.os.Looper;
24 | import android.support.annotation.CheckResult;
25 | import android.support.annotation.NonNull;
26 | import android.support.annotation.Nullable;
27 |
28 |
29 | import java.util.Arrays;
30 |
31 | import rx.Observable;
32 | import rx.Observable.OnSubscribe;
33 | import rx.Subscriber;
34 | import rx.functions.Action0;
35 | import rx.subscriptions.Subscriptions;
36 |
37 | import static com.activeandroid.sqlbrite.SqlBrite.Logger;
38 | import static com.activeandroid.sqlbrite.SqlBrite.Query;
39 |
40 | /**
41 | * A lightweight wrapper around {@link ContentResolver} which allows for continuously observing
42 | * the result of a query. Create using a {@link SqlBrite} instance.
43 | */
44 | public final class BriteContentResolver {
45 | private final Handler contentObserverHandler = new Handler(Looper.getMainLooper());
46 |
47 | private final ContentResolver contentResolver;
48 | private final Logger logger;
49 |
50 | private volatile boolean logging;
51 |
52 | BriteContentResolver(@NonNull ContentResolver contentResolver, @NonNull Logger logger) {
53 | this.contentResolver = contentResolver;
54 | this.logger = logger;
55 | }
56 |
57 | /** Control whether debug logging is enabled. */
58 | public void setLoggingEnabled(boolean enabled) {
59 | logging = enabled;
60 | }
61 |
62 | /**
63 | * Create an observable which will notify subscribers with a {@linkplain Query query} for
64 | * execution. Subscribers are responsible for always closing {@link Cursor} instance
65 | * returned from the {@link Query}.
66 | *
67 | * Subscribers will receive an immediate notification for initial data as well as subsequent
68 | * notifications for when the supplied {@code uri}'s data changes. Unsubscribe when you no longer
69 | * want updates to a query.
70 | *
71 | * Note: To skip the immediate notification and only receive subsequent notifications when data
72 | * has changed call {@code skip(1)} on the returned observable.
73 | *
74 | * Warning: this method does not perform the query! Only by subscribing to the returned
75 | * {@link Observable} will the operation occur.
76 | *
77 | * @see ContentResolver#query(Uri, String[], String, String[], String)
78 | * @see ContentResolver#registerContentObserver(Uri, boolean, ContentObserver)
79 | */
80 | @CheckResult @NonNull
81 | public QueryObservable createQuery(@NonNull final Uri uri, @Nullable final String[] projection,
82 | @Nullable final String selection, @Nullable final String[] selectionArgs, @Nullable
83 | final String sortOrder, final boolean notifyForDescendents) {
84 | final Query query = new Query() {
85 | @Override public Cursor run() {
86 | return contentResolver.query(uri, projection, selection, selectionArgs, sortOrder);
87 | }
88 | };
89 | OnSubscribe subscribe = new OnSubscribe() {
90 | @Override public void call(final Subscriber subscriber) {
91 | final ContentObserver observer = new ContentObserver(contentObserverHandler) {
92 | @Override public void onChange(boolean selfChange) {
93 | if (logging) {
94 | log("QUERY\n uri: %s\n projection: %s\n selection: %s\n selectionArgs: %s\n "
95 | + "sortOrder: %s\n notifyForDescendents: %s", uri,
96 | Arrays.toString(projection), selection, Arrays.toString(selectionArgs), sortOrder,
97 | notifyForDescendents);
98 | }
99 | subscriber.onNext(query);
100 | }
101 | };
102 | contentResolver.registerContentObserver(uri, notifyForDescendents, observer);
103 | subscriber.add(Subscriptions.create(new Action0() {
104 | @Override public void call() {
105 | contentResolver.unregisterContentObserver(observer);
106 | }
107 | }));
108 | }
109 | };
110 | Observable queryObservable = Observable.create(subscribe) //
111 | .startWith(query) //
112 | .lift(BackpressureBufferLastOperator.instance());
113 | return new QueryObservable(queryObservable);
114 | }
115 |
116 | private void log(String message, Object... args) {
117 | if (args.length > 0) message = String.format(message, args);
118 | logger.log(message);
119 | }
120 | }
121 |
--------------------------------------------------------------------------------
/src/com/activeandroid/sqlbrite/QueryObservable.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.sqlbrite;
2 |
3 | import android.database.Cursor;
4 | import android.support.annotation.CheckResult;
5 | import android.support.annotation.NonNull;
6 | import com.activeandroid.sqlbrite.SqlBrite.Query;
7 | import java.util.List;
8 | import rx.Observable;
9 | import rx.Subscriber;
10 | import rx.functions.Func1;
11 |
12 | /** An {@link Observable} of {@link Query} which offers query-specific convenience operators. */
13 | public final class QueryObservable extends Observable {
14 | QueryObservable(final Observable o) {
15 | super(new OnSubscribe() {
16 | @Override public void call(Subscriber subscriber) {
17 | o.unsafeSubscribe(subscriber);
18 | }
19 | });
20 | }
21 |
22 | /**
23 | * Given a function mapping the current row of a {@link Cursor} to {@code T}, transform each
24 | * emitted {@link Query} which returns a single row to {@code T}.
25 | *
26 | * It is an error for a query to pass through this operator with more than 1 row in its result
27 | * set. Use {@code LIMIT 1} on the underlying SQL query to prevent this. Result sets with 0 rows
28 | * do not emit an item.
29 | *
30 | * This method is equivalent to:
31 | *
{@code
32 | * flatMap(q -> q.asRows(mapper).take(1))
33 | * }
34 | *
35 | * @param mapper Maps the current {@link Cursor} row to {@code T}. May not return null.
36 | */
37 | @CheckResult @NonNull
38 | public final Observable mapToOne(@NonNull final Func1 mapper) {
39 | return lift(new QueryToOneOperator<>(mapper, false, null));
40 | }
41 |
42 | /**
43 | * Given a function mapping the current row of a {@link Cursor} to {@code T}, transform each
44 | * emitted {@link Query} which returns a single row to {@code T}.
45 | *
46 | * It is an error for a query to pass through this operator with more than 1 row in its result
47 | * set. Use {@code LIMIT 1} on the underlying SQL query to prevent this. Result sets with 0 rows
48 | * emit {@code defaultValue}.
49 | *
50 | * This method is equivalent to:
51 | *
{@code
52 | * flatMap(q -> q.asRows(mapper).take(1).defaultIfEmpty(defaultValue))
53 | * }
54 | *
55 | * @param mapper Maps the current {@link Cursor} row to {@code T}. May not return null.
56 | * @param defaultValue Value returned if result set is empty
57 | */
58 | @CheckResult @NonNull
59 | public final Observable mapToOneOrDefault(@NonNull final Func1 mapper,
60 | T defaultValue) {
61 | return lift(new QueryToOneOperator<>(mapper, true, defaultValue));
62 | }
63 |
64 | /**
65 | * Given a function mapping the current row of a {@link Cursor} to {@code T}, transform each
66 | * emitted {@link Query} to a {@code List}.
67 | *
68 | * Be careful using this operator as it will always consume the entire cursor and create objects
69 | * for each row, every time this observable emits a new query. On tables whose queries update
70 | * frequently or very large result sets this can result in the creation of many objects.
71 | *
72 | * This method is equivalent to:
73 | *
{@code
74 | * flatMap(q -> q.asRows(mapper).toList())
75 | * }
76 | * Consider using {@link Query#asRows} if you need to limit or filter in memory.
77 | *
78 | * @param mapper Maps the current {@link Cursor} row to {@code T}. May not return null.
79 | */
80 | @CheckResult @NonNull
81 | public final Observable> mapToList(@NonNull final Func1 mapper) {
82 | return lift(new QueryToListOperator<>(mapper));
83 | }
84 | }
85 |
--------------------------------------------------------------------------------
/src/com/activeandroid/sqlbrite/QueryToListOperator.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.sqlbrite;
2 |
3 | import android.database.Cursor;
4 |
5 | import java.util.ArrayList;
6 | import java.util.List;
7 |
8 | import rx.Observable;
9 | import rx.Subscriber;
10 | import rx.exceptions.Exceptions;
11 | import rx.exceptions.OnErrorThrowable;
12 | import rx.functions.Func1;
13 |
14 | final class QueryToListOperator implements Observable.Operator, SqlBrite.Query> {
15 | private final Func1 mapper;
16 |
17 | QueryToListOperator(Func1 mapper) {
18 | this.mapper = mapper;
19 | }
20 |
21 | @Override
22 | public Subscriber call(final Subscriber> subscriber) {
23 | return new Subscriber(subscriber) {
24 | @Override public void onNext(SqlBrite.Query query) {
25 | try {
26 | Cursor cursor = query.run();
27 | List items = new ArrayList<>(cursor.getCount());
28 | try {
29 | for (int i = 1; cursor.moveToNext() && !subscriber.isUnsubscribed(); i++) {
30 | T item = mapper.call(cursor);
31 | if (item == null) {
32 | throw new NullPointerException("Mapper returned null for row " + i);
33 | }
34 | items.add(item);
35 | }
36 | } finally {
37 | cursor.close();
38 | }
39 | if (!subscriber.isUnsubscribed()) {
40 | subscriber.onNext(items);
41 | }
42 | } catch (Throwable e) {
43 | Exceptions.throwIfFatal(e);
44 | onError(OnErrorThrowable.addValueAsLastCause(e, query.toString()));
45 | }
46 | }
47 |
48 | @Override public void onCompleted() {
49 | subscriber.onCompleted();
50 | }
51 |
52 | @Override public void onError(Throwable e) {
53 | subscriber.onError(e);
54 | }
55 | };
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/src/com/activeandroid/sqlbrite/QueryToOneOperator.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.sqlbrite;
2 |
3 | import android.database.Cursor;
4 |
5 | import rx.Observable;
6 | import rx.Subscriber;
7 | import rx.exceptions.Exceptions;
8 | import rx.exceptions.OnErrorThrowable;
9 | import rx.functions.Func1;
10 |
11 | final class QueryToOneOperator implements Observable.Operator {
12 | private final Func1 mapper;
13 | private boolean emitDefault;
14 | private T defaultValue;
15 |
16 | QueryToOneOperator(Func1 mapper, boolean emitDefault, T defaultValue) {
17 | this.mapper = mapper;
18 | this.emitDefault = emitDefault;
19 | this.defaultValue = defaultValue;
20 | }
21 |
22 | @Override public Subscriber call(final Subscriber subscriber) {
23 | return new Subscriber(subscriber) {
24 | @Override public void onNext(SqlBrite.Query query) {
25 | try {
26 | T item = null;
27 | Cursor cursor = query.run();
28 | try {
29 | if (cursor.moveToNext()) {
30 | item = mapper.call(cursor);
31 | if (item == null) {
32 | throw new NullPointerException("Mapper returned null for row 1");
33 | }
34 | if (cursor.moveToNext()) {
35 | throw new IllegalStateException("Cursor returned more than 1 row");
36 | }
37 | }
38 | } finally {
39 | cursor.close();
40 | }
41 | if (!subscriber.isUnsubscribed()) {
42 | if (item != null) {
43 | subscriber.onNext(item);
44 | } else if (emitDefault) {
45 | subscriber.onNext(defaultValue);
46 | }
47 | }
48 | } catch (Throwable e) {
49 | Exceptions.throwIfFatal(e);
50 | onError(OnErrorThrowable.addValueAsLastCause(e, query.toString()));
51 | }
52 | }
53 |
54 | @Override public void onCompleted() {
55 | subscriber.onCompleted();
56 | }
57 |
58 | @Override public void onError(Throwable e) {
59 | subscriber.onError(e);
60 | }
61 | };
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/src/com/activeandroid/sqlbrite/SqlBrite.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2015 Square, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package com.activeandroid.sqlbrite;
17 |
18 | import android.content.ContentResolver;
19 | import android.database.Cursor;
20 | import android.database.sqlite.SQLiteOpenHelper;
21 | import android.support.annotation.CheckResult;
22 | import android.support.annotation.NonNull;
23 | import android.util.Log;
24 | import rx.Observable;
25 | import rx.Subscriber;
26 | import rx.functions.Func1;
27 |
28 | /**
29 | * A lightweight wrapper around {@link SQLiteOpenHelper} which allows for continuously observing
30 | * the result of a query.
31 | */
32 | public final class SqlBrite {
33 | @CheckResult @NonNull
34 | public static SqlBrite create() {
35 | return create(new Logger() {
36 | @Override public void log(String message) {
37 | Log.d("SqlBrite", message);
38 | }
39 | });
40 | }
41 |
42 | @CheckResult @NonNull
43 | public static SqlBrite create(@NonNull Logger logger) {
44 | return new SqlBrite(logger);
45 | }
46 |
47 | private final Logger logger;
48 |
49 | private SqlBrite(@NonNull Logger logger) {
50 | this.logger = logger;
51 | }
52 |
53 | /**
54 | * Wrap a {@link SQLiteOpenHelper} for observable queries.
55 | *
56 | * While not strictly required, instances of this class assume that they will be the only ones
57 | * interacting with the underlying {@link SQLiteOpenHelper} and it is required for automatic
58 | * notifications of table changes to work. See {@linkplain BriteDatabase#createQuery the
59 | * query method} for more information on that behavior.
60 | */
61 | @CheckResult @NonNull
62 | public BriteDatabase wrapDatabaseHelper(@NonNull SQLiteOpenHelper helper) {
63 | return new BriteDatabase(helper, logger);
64 | }
65 |
66 | /** Wrap a {@link ContentResolver} for observable queries. */
67 | @CheckResult @NonNull
68 | public BriteContentResolver wrapContentProvider(@NonNull ContentResolver contentResolver) {
69 | return new BriteContentResolver(contentResolver, logger);
70 | }
71 |
72 | /** An executable query. */
73 | public static abstract class Query {
74 | /** Execute the query on the underlying database and return the resulting cursor. */
75 | @CheckResult // TODO @WorkerThread
76 | // TODO Implementations might return null, which is gross. Throw?
77 | public abstract Cursor run();
78 |
79 | /**
80 | * Execute the query on the underlying database and return an Observable of each row mapped to
81 | * {@code T} by {@code mapper}.
82 | *
83 | * Standard usage of this operation is in {@code flatMap}:
84 | *
{@code
85 | * flatMap(q -> q.asRows(Item.MAPPER).toList())
86 | * }
87 | * However, the above is a more-verbose but identical operation as
88 | * {@link QueryObservable#mapToList}. This {@code asRows} method should be used when you need
89 | * to limit or filter the items separate from the actual query.
90 | * {@code
91 | * flatMap(q -> q.asRows(Item.MAPPER).take(5).toList())
92 | * // or...
93 | * flatMap(q -> q.asRows(Item.MAPPER).filter(i -> i.isActive).toList())
94 | * }
95 | *
96 | * Note: Limiting results or filtering will almost always be faster in the database as part of
97 | * a query and should be preferred, where possible.
98 | */
99 | @CheckResult @NonNull
100 | public final Observable asRows(final Func1 mapper) {
101 | return Observable.create(new Observable.OnSubscribe() {
102 | @Override public void call(Subscriber subscriber) {
103 | Cursor cursor = run();
104 | try {
105 | while (cursor.moveToNext() && !subscriber.isUnsubscribed()) {
106 | subscriber.onNext(mapper.call(cursor));
107 | }
108 | } finally {
109 | cursor.close();
110 | }
111 | if (!subscriber.isUnsubscribed()) {
112 | subscriber.onCompleted();
113 | }
114 | }
115 | });
116 | }
117 | }
118 |
119 | /** A simple indirection for logging debug messages. */
120 | public interface Logger {
121 | void log(String message);
122 | }
123 | }
124 |
--------------------------------------------------------------------------------
/src/com/activeandroid/util/IOUtils.java:
--------------------------------------------------------------------------------
1 |
2 | package com.activeandroid.util;
3 |
4 | /*
5 | * Copyright (C) 2014 Markus Pfeiffer
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * you may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS,
15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | */
19 |
20 | import android.database.Cursor;
21 |
22 | import java.io.Closeable;
23 | import java.io.IOException;
24 |
25 | import com.activeandroid.util.Log;
26 |
27 |
28 | public class IOUtils {
29 |
30 | /**
31 | *
32 | * Unconditionally close a {@link Closeable}.
33 | *
34 | * Equivalent to {@link Closeable#close()}, except any exceptions will be ignored. This is
35 | * typically used in finally blocks.
36 | * @param closeable A {@link Closeable} to close.
37 | */
38 | public static void closeQuietly(final Closeable closeable) {
39 |
40 | if (closeable == null) {
41 | return;
42 | }
43 |
44 | try {
45 | closeable.close();
46 | } catch (final IOException e) {
47 | Log.e("Couldn't close closeable.", e);
48 | }
49 | }
50 |
51 | /**
52 | *
53 | * Unconditionally close a {@link Cursor}.
54 | *
55 | * Equivalent to {@link Cursor#close()}, except any exceptions will be ignored. This is
56 | * typically used in finally blocks.
57 | * @param cursor A {@link Cursor} to close.
58 | */
59 | public static void closeQuietly(final Cursor cursor) {
60 |
61 | if (cursor == null) {
62 | return;
63 | }
64 |
65 | try {
66 | cursor.close();
67 | } catch (final Exception e) {
68 | Log.e("Couldn't close cursor.", e);
69 | }
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/src/com/activeandroid/util/Log.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.util;
2 |
3 | /*
4 | * Copyright (C) 2010 Michael Pardo
5 | *
6 | * Licensed under the Apache License, Version 2.0 (the "License");
7 | * you may not use this file except in compliance with the License.
8 | * You may obtain a copy of the License at
9 | *
10 | * http://www.apache.org/licenses/LICENSE-2.0
11 | *
12 | * Unless required by applicable law or agreed to in writing, software
13 | * distributed under the License is distributed on an "AS IS" BASIS,
14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | * See the License for the specific language governing permissions and
16 | * limitations under the License.
17 | */
18 |
19 | public final class Log {
20 | //////////////////////////////////////////////////////////////////////////////////////
21 | // PUBLIC MEMBERS
22 | //////////////////////////////////////////////////////////////////////////////////////
23 |
24 | private static String sTag = "ActiveAndroid";
25 | private static boolean sEnabled = false;
26 |
27 | //////////////////////////////////////////////////////////////////////////////////////
28 | // CONSTRUCTORS
29 | //////////////////////////////////////////////////////////////////////////////////////
30 |
31 | private Log() {
32 | }
33 |
34 | //////////////////////////////////////////////////////////////////////////////////////
35 | // PUBLIC METHODS
36 | //////////////////////////////////////////////////////////////////////////////////////
37 |
38 | public static boolean isEnabled() {
39 | return sEnabled;
40 | }
41 |
42 | public static void setEnabled(boolean enabled) {
43 | sEnabled = enabled;
44 | }
45 |
46 | public static boolean isLoggingEnabled() {
47 | return sEnabled;
48 | }
49 |
50 | public static int v(String msg) {
51 | if (sEnabled) {
52 | return android.util.Log.v(sTag, msg);
53 | }
54 | return 0;
55 | }
56 |
57 | public static int v(String tag, String msg) {
58 | if (sEnabled) {
59 | return android.util.Log.v(tag, msg);
60 | }
61 | return 0;
62 | }
63 |
64 | public static int v(String msg, Throwable tr) {
65 | if (sEnabled) {
66 | return android.util.Log.v(sTag, msg, tr);
67 | }
68 | return 0;
69 | }
70 |
71 | public static int v(String tag, String msg, Throwable tr) {
72 | if (sEnabled) {
73 | return android.util.Log.v(tag, msg, tr);
74 | }
75 | return 0;
76 | }
77 |
78 | public static int d(String msg) {
79 | if (sEnabled) {
80 | return android.util.Log.d(sTag, msg);
81 | }
82 | return 0;
83 | }
84 |
85 | public static int d(String tag, String msg) {
86 | if (sEnabled) {
87 | return android.util.Log.d(tag, msg);
88 | }
89 | return 0;
90 | }
91 |
92 | public static int d(String msg, Throwable tr) {
93 | if (sEnabled) {
94 | return android.util.Log.d(sTag, msg, tr);
95 | }
96 | return 0;
97 | }
98 |
99 | public static int d(String tag, String msg, Throwable tr) {
100 | if (sEnabled) {
101 | return android.util.Log.d(tag, msg, tr);
102 | }
103 | return 0;
104 | }
105 |
106 | public static int i(String msg) {
107 | if (sEnabled) {
108 | return android.util.Log.i(sTag, msg);
109 | }
110 | return 0;
111 | }
112 |
113 | public static int i(String tag, String msg) {
114 | if (sEnabled) {
115 | return android.util.Log.i(tag, msg);
116 | }
117 | return 0;
118 | }
119 |
120 | public static int i(String msg, Throwable tr) {
121 | if (sEnabled) {
122 | return android.util.Log.i(sTag, msg, tr);
123 | }
124 | return 0;
125 | }
126 |
127 | public static int i(String tag, String msg, Throwable tr) {
128 | if (sEnabled) {
129 | return android.util.Log.i(tag, msg, tr);
130 | }
131 | return 0;
132 | }
133 |
134 | public static int w(String msg) {
135 | if (sEnabled) {
136 | return android.util.Log.w(sTag, msg);
137 | }
138 | return 0;
139 | }
140 |
141 | public static int w(String tag, String msg) {
142 | if (sEnabled) {
143 | return android.util.Log.w(tag, msg);
144 | }
145 | return 0;
146 | }
147 |
148 | public static int w(String msg, Throwable tr) {
149 | if (sEnabled) {
150 | return android.util.Log.w(sTag, msg, tr);
151 | }
152 | return 0;
153 | }
154 |
155 | public static int w(String tag, String msg, Throwable tr) {
156 | if (sEnabled) {
157 | return android.util.Log.w(tag, msg, tr);
158 | }
159 | return 0;
160 | }
161 |
162 | public static int e(String msg) {
163 | if (sEnabled) {
164 | return android.util.Log.e(sTag, msg);
165 | }
166 | return 0;
167 | }
168 |
169 | public static int e(String tag, String msg) {
170 | if (sEnabled) {
171 | return android.util.Log.e(tag, msg);
172 | }
173 | return 0;
174 | }
175 |
176 | public static int e(String msg, Throwable tr) {
177 | if (sEnabled) {
178 | return android.util.Log.e(sTag, msg, tr);
179 | }
180 | return 0;
181 | }
182 |
183 | public static int e(String tag, String msg, Throwable tr) {
184 | if (sEnabled) {
185 | return android.util.Log.e(tag, msg, tr);
186 | }
187 | return 0;
188 | }
189 |
190 | public static int t(String msg, Object... args) {
191 | if (sEnabled) {
192 | return android.util.Log.v("test", String.format(msg, args));
193 | }
194 | return 0;
195 | }
196 | }
--------------------------------------------------------------------------------
/src/com/activeandroid/util/NaturalOrderComparator.java:
--------------------------------------------------------------------------------
1 | package com.activeandroid.util;
2 |
3 | /*
4 | NaturalOrderComparator.java -- Perform 'natural order' comparisons of strings in Java.
5 | Copyright (C) 2003 by Pierre-Luc Paour
6 |
7 | Based on the C version by Martin Pool, of which this is more or less a straight conversion.
8 | Copyright (C) 2000 by Martin Pool
9 |
10 | This software is provided 'as-is', without any express or implied
11 | warranty. In no event will the authors be held liable for any damages
12 | arising from the use of this software.
13 |
14 | Permission is granted to anyone to use this software for any purpose,
15 | including commercial applications, and to alter it and redistribute it
16 | freely, subject to the following restrictions:
17 |
18 | 1. The origin of this software must not be misrepresented; you must not
19 | claim that you wrote the original software. If you use this software
20 | in a product, an acknowledgment in the product documentation would be
21 | appreciated but is not required.
22 | 2. Altered source versions must be plainly marked as such, and must not be
23 | misrepresented as being the original software.
24 | 3. This notice may not be removed or altered from any source distribution.
25 | */
26 |
27 | import java.util.Comparator;
28 |
29 | public class NaturalOrderComparator implements Comparator