text stringlengths 9 39.2M | dir stringlengths 26 295 | lang stringclasses 185
values | created_date timestamp[us] | updated_date timestamp[us] | repo_name stringlengths 1 97 | repo_full_name stringlengths 7 106 | star int64 1k 183k | len_tokens int64 1 13.8M |
|---|---|---|---|---|---|---|---|---|
```java
package com.arellomobile.mvp.provide_methods_test.resources;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.ProvidePresenter;
/**
* Date: 30.12.2016
* Time: 10:12
*
* @author Yuri Shmakov
*/
public class SuperView implements TestView {
@InjectPresenter
public TestPresenter oneLocalPresenter;
public TestPresenter oneLocalProvidedPresenter;
@InjectPresenter
public TestPresenter secondLocalPresenter;
@InjectPresenter(presenterId = "one_global")
public TestPresenter oneGlobalPresenter;
@InjectPresenter(presenterId = "second_global")
public TestPresenter secondGlobalPresenter;
public MvpDelegate<SuperView> delegate;
@ProvidePresenter
public TestPresenter provideLocalPresenter() {
oneLocalProvidedPresenter = new TestPresenter();
return oneLocalProvidedPresenter;
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/provide_methods_test/resources/SuperView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 199 |
```java
package com.arellomobile.mvp.view;
import com.arellomobile.mvp.GenerateViewState;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.strategy.AddToEndSingleStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 29.02.2016
* Time: 9:09
*
* @author Savin Mikhail
*/
@GenerateViewState
public interface ParentView extends MvpView {
void withoutStrategyMethod();
@StateStrategyType(AddToEndSingleStrategy.class)
void customStrategyMethod();
@StateStrategyType(AddToEndSingleStrategy.class)
void parentOverrideMethodWithCustomStrategy();
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/ParentView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 145 |
```java
package com.arellomobile.mvp.provide_methods_test.resources;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.ProvidePresenter;
/**
* Date: 30.12.2016
* Time: 12:05
*
* @author Yuri Shmakov
*/
public class LocalProvidedView implements TestView {
@InjectPresenter
public TestPresenter oneLocalPresenter;
public TestPresenter oneLocalProvidedPresenter;
public MvpDelegate<LocalProvidedView> delegate;
@ProvidePresenter
TestPresenter provideLocalPresenter() {
oneLocalProvidedPresenter = new TestPresenter();
return oneLocalProvidedPresenter;
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/provide_methods_test/resources/LocalProvidedView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 155 |
```java
package com.arellomobile.mvp.view;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.InjectViewStatePresenter;
import com.arellomobile.mvp.presenter.PresenterType;
public class DelegateLocalPresenterTestView extends CounterTestView {
@InjectPresenter(type = PresenterType.LOCAL)
public InjectViewStatePresenter mInjectViewStatePresenter;
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/DelegateLocalPresenterTestView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 77 |
```java
package com.arellomobile.mvp.view;
import java.util.HashMap;
import java.util.Map;
/**
* Date: 10.02.2016
* Time: 13:22
*
* @author Savin Mikhail
*/
public class CounterTestView implements TestView {
public final Map<String, Integer> counterEvents = new HashMap<>();
@Override
public void testEvent() {
String testEvent = "testEvent";
if (counterEvents.containsKey(testEvent)) {
counterEvents.put(testEvent, counterEvents.get(testEvent) + 1);
} else {
counterEvents.put(testEvent, 1);
}
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/CounterTestView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 137 |
```java
package com.arellomobile.mvp.view;
import com.arellomobile.mvp.MvpView;
/**
* Date: 08.02.2016
* Time: 16:29
*
* @author Savin Mikhail
*/
public interface TestView extends MvpView {
void testEvent();
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/TestView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 64 |
```java
package com.arellomobile.mvp.view;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.InjectViewStatePresenter;
import com.arellomobile.mvp.presenter.PresenterType;
public class DelegateLocalPresenter2TestView extends CounterTestView {
@InjectPresenter(type = PresenterType.LOCAL)
public InjectViewStatePresenter mInjectViewStatePresenter;
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/DelegateLocalPresenter2TestView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 78 |
```java
package com.arellomobile.mvp.view;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.InjectViewStatePresenter;
import com.arellomobile.mvp.presenter.PresenterType;
public class DelegateGlobalTestView extends CounterTestView {
public static final String TEST_GLOBAL_PRESENTER = "TestGlobalPresenter";
@InjectPresenter(type = PresenterType.GLOBAL, tag = TEST_GLOBAL_PRESENTER)
public InjectViewStatePresenter mInjectViewStatePresenter;
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/DelegateGlobalTestView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 99 |
```java
package com.arellomobile.mvp.view;
import com.arellomobile.mvp.MvpView;
/**
* Date: 26.02.2016
* Time: 11:36
*
* @author Savin Mikhail
*/
public interface PositiveViewStateView extends MvpView {
void method();
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/PositiveViewStateView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 64 |
```java
package com.arellomobile.mvp.view;
import com.arellomobile.mvp.GenerateViewState;
import com.arellomobile.mvp.viewstate.strategy.SkipStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 29.02.2016
* Time: 9:10
*
* @author Savin Mikhail
*/
@GenerateViewState
@StateStrategyType(SkipStrategy.class)
public interface ChildView extends ParentView, SimpleInterface {
@Override
void parentOverrideMethodWithCustomStrategy();
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/ChildView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 112 |
```java
package com.arellomobile.mvp.view;
import com.arellomobile.mvp.MvpView;
/**
* Date: 04.03.2016
* Time: 14:48
*
* @author Savin Mikhail
*/
public abstract class TestViewChild2<T extends MvpView> extends TestViewChild<T> {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/TestViewChild2.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 69 |
```java
package com.arellomobile.mvp.view;
import com.arellomobile.mvp.MvpView;
/**
* Date: 15.03.2016
* Time: 13:56
*
* @author Savin Mikhail
*/
public interface TestView2 extends MvpView {
void testEvent(Object o);
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/TestView2.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 67 |
```java
package com.arellomobile.mvp.view;
/**
* Date: 29.02.2016
* Time: 9:11
*
* @author Savin Mikhail
*/
public interface SimpleInterface {
void simpleInterfaceMethod();
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/SimpleInterface.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 50 |
```java
package com.arellomobile.mvp.view;
import com.arellomobile.mvp.MvpView;
/**
* Date: 04.03.2016
* Time: 14:48
*
* @author Savin Mikhail
*/
public abstract class TestViewChild<T extends MvpView> implements TestView {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/view/TestViewChild.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 66 |
```java
package com.arellomobile.mvp.inheritance_test.resources;
import com.arellomobile.mvp.MvpView;
/**
* Date: 29.12.2016
* Time: 14:31
*
* @author Yuri Shmakov
*/
public interface TestView extends MvpView {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/inheritance_test/resources/TestView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 64 |
```java
package com.arellomobile.mvp.inheritance_test.resources;
import com.arellomobile.mvp.MvpPresenter;
/**
* Date: 29.12.2016
* Time: 14:32
*
* @author Yuri Shmakov
*/
@SuppressWarnings("WeakerAccess")
public class TestPresenter extends MvpPresenter<TestView> {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/inheritance_test/resources/TestPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 73 |
```java
package com.arellomobile.mvp.inheritance_test;
import android.os.Bundle;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.inheritance_test.resources.ChildViewWithoutInject;
import com.arellomobile.mvp.inheritance_test.resources.SuperViewWithInject;
import com.arellomobile.mvp.inheritance_test.resources.ViewWithoutInject;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Date: 30.12.2016
* Time: 00:29
*
* @author Yuri Shmakov
*/
@RunWith(RobolectricTestRunner.class)
@Config(manifest = Config.NONE)
public class InheritanceTest {
@Test
public void testWithoutInject() {
ViewWithoutInject view = new ViewWithoutInject();
view.delegate = new MvpDelegate<>(view);
view.delegate.onCreate(new Bundle());
}
@Test
public void testInjectInInherited() {
SuperViewWithInject view = new SuperViewWithInject();
view.delegate = new MvpDelegate<>(view);
view.delegate.onCreate(new Bundle());
Assert.assertNotNull(view.presenter);
}
@Test
public void testInjectOnlyInSuper() {
ChildViewWithoutInject view = new ChildViewWithoutInject();
view.delegate = new MvpDelegate<>(view);
view.delegate.onCreate();
Assert.assertNotNull(view.presenter);
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/inheritance_test/InheritanceTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 307 |
```java
package com.arellomobile.mvp.inheritance_test.resources;
import com.arellomobile.mvp.MvpDelegate;
/**
* Date: 30.12.2016
* Time: 00:09
*
* @author Yuri Shmakov
*/
public class ViewWithoutInject {
public MvpDelegate<? extends ViewWithoutInject> delegate;
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/inheritance_test/resources/ViewWithoutInject.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 73 |
```java
package com.arellomobile.mvp.inheritance_test.resources;
/**
* Date: 30.12.2016
* Time: 00:13
*
* @author Yuri Shmakov
*/
public class ChildViewWithoutInject extends SuperViewWithInject implements TestView {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/inheritance_test/resources/ChildViewWithoutInject.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 59 |
```java
package com.arellomobile.mvp.presenter;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.view.TestView;
/**
* Date: 10.02.2016
* Time: 13:24
*
* @author Savin Mikhail
*/
public class TestViewPresenter extends MvpPresenter<TestView> {
public void testEvent() {
getViewState().testEvent();
}
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/presenter/TestViewPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 90 |
```java
package com.arellomobile.mvp.inheritance_test.resources;
import com.arellomobile.mvp.presenter.InjectPresenter;
/**
* Date: 30.12.2016
* Time: 00:11
*
* @author Yuri Shmakov
*/
public class SuperViewWithInject extends ViewWithoutInject implements TestView {
@InjectPresenter
public TestPresenter presenter;
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/inheritance_test/resources/SuperViewWithInject.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 78 |
```java
package com.arellomobile.mvp.presenter;
/**
* Date: 08.02.2016
* Time: 16:29
*
* @author Savin Mikhail
*/
public class NoViewStatePresenter extends TestViewPresenter {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/presenter/NoViewStatePresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 50 |
```java
package com.arellomobile.mvp.presenter;
import com.arellomobile.mvp.InjectViewState;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.view.PositiveViewStateView;
/**
* Date: 15.03.2016
* Time: 14:39
*
* @author Savin Mikhail
*/
@InjectViewState
public class InjectViewStatePositivePresenter extends MvpPresenter<PositiveViewStateView> {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/presenter/InjectViewStatePositivePresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 92 |
```java
package com.arellomobile.mvp.presenter;
import com.arellomobile.mvp.InjectViewState;
/**
* Date: 08.02.2016
* Time: 16:29
*
* @author Savin Mikhail
*/
@InjectViewState
public class InjectViewStatePresenter extends TestViewPresenter {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/presenter/InjectViewStatePresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 63 |
```java
package com.arellomobile.mvp.presenter;
import com.arellomobile.mvp.InjectViewState;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.view.PositiveViewStateView;
/**
* Date: 26.02.2016
* Time: 17:38
*
* @author Savin Mikhail
*/
@InjectViewState
public class PositiveViewStateProviderPresenter extends MvpPresenter<PositiveViewStateView> {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/presenter/PositiveViewStateProviderPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 92 |
```java
package com.arellomobile.mvp.presenter;
import com.arellomobile.mvp.InjectViewState;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.view.TestView2;
/**
* Date: 15.03.2016
* Time: 13:57
*
* @author Savin Mikhail
*/
@InjectViewState
public class InjectViewStatePresenter2 extends MvpPresenter<TestView2> {
}
``` | /content/code_sandbox/moxy/src/test/java/com/arellomobile/mvp/presenter/InjectViewStatePresenter2.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 91 |
```java
package com.arellomobile.mvp;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.TYPE;
/**
* <p>Generate view state class for annotated view interface.</p>
* <p>Generated class implements this view interface.</p>
*
* @deprecated As of release 0.4.1, {@link InjectViewState} generate view state, if it needed
*/
@Target(value = TYPE)
@Deprecated
public @interface GenerateViewState {
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/GenerateViewState.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 97 |
```java
package com.arellomobile.mvp;
/**
* Date: 17-Dec-15
* Time: 19:00
*
* @author Alexander Blinov
* @author Yuri Shmakov
*/
@SuppressWarnings({"WeakerAccess", "unused"})
public final class MvpFacade {
private static volatile MvpFacade sInstance;
private static final Object sLock = new Object();
public static MvpFacade getInstance() {
if (sInstance == null) {
synchronized (sLock) {
if (sInstance == null) {
sInstance = new MvpFacade();
}
}
}
return sInstance;
}
public static void init() {
getInstance();
}
private MvpFacade() {
mPresentersCounter = new PresentersCounter();
mPresenterStore = new PresenterStore();
mMvpProcessor = new MvpProcessor();
}
private PresenterStore mPresenterStore;
private MvpProcessor mMvpProcessor;
private PresentersCounter mPresentersCounter;
public PresenterStore getPresenterStore() {
return mPresenterStore;
}
public void setPresenterStore(PresenterStore presenterStore) {
mPresenterStore = presenterStore;
}
public MvpProcessor getMvpProcessor() {
return mMvpProcessor;
}
public void setMvpProcessor(MvpProcessor mvpProcessor) {
mMvpProcessor = mvpProcessor;
}
public PresentersCounter getPresentersCounter() {
return mPresentersCounter;
}
public void setPresentersCounter(PresentersCounter presentersCounter) {
mPresentersCounter = presentersCounter;
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/MvpFacade.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 342 |
```java
package com.arellomobile.mvp;
/**
* Date: 21.01.2016
* Time: 19:58
*
* @author Yuri Shmakov
*/
public interface MvpView {
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/MvpView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 46 |
```java
package com.arellomobile.mvp;
import java.lang.annotation.Target;
import com.arellomobile.mvp.viewstate.MvpViewState;
import static java.lang.annotation.ElementType.TYPE;
/**
* Inject view state to {@link MvpPresenter#mViews} and
* {@link MvpPresenter#mViewState} presenter fields. Presenter, annotated with
* this, should be strongly typed on view interface(not write some like extends
* MvpPresenter<V extends SuperView>). Otherwise code generation make
* code, that broke your app.
*/
@Target(value = TYPE)
public @interface InjectViewState {
Class<? extends MvpViewState> value() default DefaultViewState.class;
Class<? extends MvpView> view() default DefaultView.class;
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/InjectViewState.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 156 |
```java
package com.arellomobile.mvp;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import com.arellomobile.mvp.presenter.PresenterField;
import com.arellomobile.mvp.presenter.PresenterType;
/**
* Date: 18-Dec-15
* Time: 13:16
*
* @author Yuri Shmakov
* @author Alexander Blinov
*/
public class MvpProcessor {
public static final String PRESENTER_BINDER_SUFFIX = "$$PresentersBinder";
public static final String PRESENTER_BINDER_INNER_SUFFIX = "Binder";
public static final String VIEW_STATE_SUFFIX = "$$State";
public static final String VIEW_STATE_PROVIDER_SUFFIX = "$$ViewStateProvider";
/**
* <p>1) Generates tag for identification MvpPresenter</p>
* <p>2) Checks if presenter with tag is already exist in {@link com.arellomobile.mvp.PresenterStore}, and returns it</p>
* <p>3) If {@link com.arellomobile.mvp.PresenterStore} doesn't contain MvpPresenter with current tag, {@link PresenterField} will create it</p>
*
* @param <Delegated> type of delegated
* @param target object that want injection
* @param presenterField info about presenter from {@link com.arellomobile.mvp.presenter.InjectPresenter}
* @param delegateTag unique tag generated by {@link MvpDelegate#generateTag()} @return MvpPresenter instance
*/
private <Delegated> MvpPresenter<? super Delegated> getMvpPresenter(Delegated target, PresenterField<Delegated> presenterField, String delegateTag) {
Class<? extends MvpPresenter<?>> presenterClass = presenterField.getPresenterClass();
PresenterStore presenterStore = MvpFacade.getInstance().getPresenterStore();
PresenterType type = presenterField.getPresenterType();
String tag;
if (type == PresenterType.LOCAL) {
tag = delegateTag + "$" + presenterField.getTag(target);
} else {
tag = presenterField.getTag(target);
}
//noinspection unchecked
MvpPresenter<? super Delegated> presenter = presenterStore.get(tag);
if (presenter != null) {
return presenter;
}
//noinspection unchecked
presenter = (MvpPresenter<? super Delegated>) presenterField.providePresenter(target);
if (presenter == null) {
return null;
}
presenter.setPresenterType(type);
presenter.setTag(tag);
presenter.setPresenterClass(presenterClass);
presenterStore.add(tag, presenter);
return presenter;
}
/**
* <p>Gets presenters {@link java.util.List} annotated with {@link com.arellomobile.mvp.presenter.InjectPresenter} for view.</p>
* <p>See full info about getting presenter instance in {@link #getMvpPresenter}</p>
*
* @param delegated class contains presenter
* @param delegateTag unique tag generated by {@link MvpDelegate#generateTag()}
* @param <Delegated> type of delegated
* @return presenters list for specifies presenters container
*/
<Delegated> List<MvpPresenter<? super Delegated>> getMvpPresenters(Delegated delegated, String delegateTag) {
if (!hasMoxyReflector()) {
return Collections.emptyList();
}
@SuppressWarnings("unchecked")
Class<? super Delegated> aClass = (Class<Delegated>) delegated.getClass();
List<Object> presenterBinders = null;
while (aClass != Object.class && presenterBinders == null) {
presenterBinders = MoxyReflector.getPresenterBinders(aClass);
aClass = aClass.getSuperclass();
}
if (presenterBinders == null || presenterBinders.isEmpty()) {
return Collections.emptyList();
}
List<MvpPresenter<? super Delegated>> presenters = new ArrayList<>();
PresentersCounter presentersCounter = MvpFacade.getInstance().getPresentersCounter();
for (Object presenterBinderObject : presenterBinders) {
//noinspection unchecked
PresenterBinder<Delegated> presenterBinder = (PresenterBinder<Delegated>) presenterBinderObject;
List<PresenterField<Delegated>> presenterFields = presenterBinder.getPresenterFields();
for (PresenterField<Delegated> presenterField : presenterFields) {
MvpPresenter<? super Delegated> presenter = getMvpPresenter(delegated, presenterField, delegateTag);
if (presenter != null) {
presentersCounter.injectPresenter(presenter, delegateTag);
presenters.add(presenter);
presenterField.bind(delegated, presenter);
}
}
}
return presenters;
}
private static Boolean hasMoxyReflector = null;
// Check is it have generated MoxyReflector without usage of reflection API
private static boolean hasMoxyReflector() {
if (hasMoxyReflector != null) {
return hasMoxyReflector;
}
try {
new MoxyReflector();
hasMoxyReflector = true;
} catch (NoClassDefFoundError error) {
hasMoxyReflector = false;
}
return hasMoxyReflector;
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/MvpProcessor.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 1,161 |
```java
package com.arellomobile.mvp;
/**
* Date: 04.02.2016
* Time: 14:15
*
* @author Yuri Shmakov
*/
public interface DefaultView extends MvpView {
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/DefaultView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 49 |
```java
package com.arellomobile.mvp;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* Date: 14-Nov-16
* Time: 04:39
*
* @author Yuri Shmakov
*/
@SuppressWarnings("WeakerAccess")
public class PresentersCounter {
private Map<MvpPresenter<?>, Set<String>> mConnections = new HashMap<>();
private Map<String, Set<MvpPresenter>> mTags = new HashMap<>();
/**
* Save delegate tag when it inject presenter to delegate's object
*
* @param presenter Injected presenter
* @param delegateTag Delegate tag
*/
public void injectPresenter(MvpPresenter<?> presenter, String delegateTag) {
Set<String> delegateTags = mConnections.get(presenter);
if (delegateTags == null) {
delegateTags = new HashSet<>();
mConnections.put(presenter, delegateTags);
}
delegateTags.add(delegateTag);
Set<MvpPresenter> presenters = mTags.get(delegateTag);
if (presenters == null) {
presenters = new HashSet<>();
mTags.put(delegateTag, presenters);
}
presenters.add(presenter);
}
/**
* Remove tag when delegate's object was fully destroyed
*
* @param presenter Rejected presenter
* @param delegateTag Delegate tag
* @return True if there are no links to this presenter and presenter be able to destroy. False otherwise
*/
public boolean rejectPresenter(MvpPresenter<?> presenter, String delegateTag) {
Set<MvpPresenter> presenters = mTags.get(delegateTag);
if (presenters != null) {
presenters.remove(presenter);
}
if (presenters == null || presenters.isEmpty()) {
mTags.remove(delegateTag);
}
Set<String> delegateTags = mConnections.get(presenter);
if (delegateTags == null) {
mConnections.remove(presenter);
return true;
}
Iterator<String> tagsIterator = delegateTags.iterator();
while (tagsIterator.hasNext()) {
String tag = tagsIterator.next();
if (tag.startsWith(delegateTag)) {
tagsIterator.remove();
}
}
boolean noTags = delegateTags.isEmpty();
if (noTags) {
mConnections.remove(presenter);
}
return noTags;
}
public Set<MvpPresenter> getAll(String delegateTag) {
Set<MvpPresenter> presenters = new HashSet<>();
for (Map.Entry<String, Set<MvpPresenter>> tagsWithPresenters : mTags.entrySet()) {
if (tagsWithPresenters.getKey().startsWith(delegateTag)) {
presenters.addAll(tagsWithPresenters.getValue());
}
}
return presenters;
}
@SuppressWarnings("unused")
public boolean isInjected(MvpPresenter<?> presenter) {
Set<String> mDelegateTags = mConnections.get(presenter);
return mDelegateTags != null && !mDelegateTags.isEmpty();
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/PresentersCounter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 649 |
```java
package com.arellomobile.mvp;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.TYPE;
/**
* Register MoxyReflector packages from other modules
*/
@Target(value = TYPE)
public @interface RegisterMoxyReflectorPackages {
String[] value();
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/RegisterMoxyReflectorPackages.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 58 |
```java
package com.arellomobile.mvp;
import com.arellomobile.mvp.viewstate.MvpViewState;
/**
* Date: 18.12.2015
* Time: 13:15
*
* @author Yuri Shmakov
*/
public abstract class ViewStateProvider {
/**
* <p>Presenter creates view state object by calling this method.</p>
*
* @return view state class name
*/
public abstract MvpViewState getViewState();
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/ViewStateProvider.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 99 |
```java
package com.arellomobile.mvp;
import java.util.Collections;
import java.util.Set;
import java.util.WeakHashMap;
import com.arellomobile.mvp.presenter.PresenterType;
import com.arellomobile.mvp.viewstate.MvpViewState;
/**
* Date: 15.12.2015
* Time: 19:31
*
* @author Yuri Shmakov
* @author Alexander Blinov
* @author Konstantin Tckhovrebov
*/
public abstract class MvpPresenter<View extends MvpView> {
private boolean mFirstLaunch = true;
private String mTag;
private PresenterType mPresenterType;
private Set<View> mViews;
private View mViewStateAsView;
private MvpViewState<View> mViewState;
private Class<? extends MvpPresenter<?>> mPresenterClass;
public MvpPresenter() {
Binder.bind(this);
mViews = Collections.newSetFromMap(new WeakHashMap<View, Boolean>());
}
/**
* <p>Attach view to view state or to presenter(if view state not exists).</p>
* <p>If you use {@link MvpDelegate}, you should not call this method directly.
* It will be called on {@link MvpDelegate#onAttach()}, if view does not attached.</p>
*
* @param view to attachment
*/
public void attachView(View view) {
if (mViewState != null) {
mViewState.attachView(view);
} else {
mViews.add(view);
}
if (mFirstLaunch) {
mFirstLaunch = false;
onFirstViewAttach();
}
}
/**
* <p>Callback after first presenter init and view binding. If this
* presenter instance will have to attach some view in future, this method
* will not be called.</p>
* <p>There you can to interact with {@link #mViewState}.</p>
*/
protected void onFirstViewAttach() {
}
/**
* <p>Detach view from view state or from presenter(if view state not exists).</p>
* <p>If you use {@link MvpDelegate}, you should not call this method directly.
* It will be called on {@link MvpDelegate#onDetach()}.</p>
*
* @param view view to detach
*/
@SuppressWarnings("WeakerAccess")
public void detachView(View view) {
if (mViewState != null) {
mViewState.detachView(view);
} else {
mViews.remove(view);
}
}
public void destroyView(View view) {
if (mViewState != null) {
mViewState.destroyView(view);
}
}
/**
* @return views attached to view state, or attached to presenter(if view state not exists)
*/
@SuppressWarnings("WeakerAccess")
public Set<View> getAttachedViews() {
if (mViewState != null) {
return mViewState.getViews();
}
return mViews;
}
/**
* @return view state, casted to view interface for simplify
*/
@SuppressWarnings("WeakerAccess")
public View getViewState() {
return mViewStateAsView;
}
/**
* Check if view is in restore state or not
*
* @param view view for check
* @return true if view state restore state to incoming view. false otherwise.
*/
@SuppressWarnings("unused")
public boolean isInRestoreState(View view) {
//noinspection SimplifiableIfStatement
if (mViewState != null) {
return mViewState.isInRestoreState(view);
}
return false;
}
/**
* Set view state to presenter
*
* @param viewState that implements type, setted as View generic param
*/
@SuppressWarnings({"unchecked", "unused"})
public void setViewState(MvpViewState<View> viewState) {
mViewStateAsView = (View) viewState;
mViewState = (MvpViewState) viewState;
}
PresenterType getPresenterType() {
return mPresenterType;
}
void setPresenterType(PresenterType presenterType) {
mPresenterType = presenterType;
}
String getTag() {
return mTag;
}
void setTag(String tag) {
mTag = tag;
}
void setPresenterClass(Class<? extends MvpPresenter<?>> presenterClass) {
mPresenterClass = presenterClass;
}
Class<? extends MvpPresenter<?>> getPresenterClass() {
return mPresenterClass;
}
/**
* <p>Called before reference on this presenter will be cleared and instance of presenter
* will be never used.</p>
*/
public void onDestroy() {
}
private static class Binder {
static void bind(MvpPresenter presenter) {
MvpView viewState = (MvpView) MoxyReflector.getViewState(presenter.getClass());
presenter.mViewStateAsView = viewState;
presenter.mViewState = (MvpViewState) viewState;
}
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/MvpPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 1,069 |
```java
package com.arellomobile.mvp;
import java.util.List;
import com.arellomobile.mvp.presenter.PresenterField;
/**
* Date: 18-Dec-15
* Time: 18:42
*
* @author Alexander Blinov
*/
public abstract class PresenterBinder<PresentersContainer> {
public abstract List<PresenterField<PresentersContainer>> getPresenterFields();
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/PresenterBinder.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 81 |
```java
package com.arellomobile.mvp;
import com.arellomobile.mvp.viewstate.MvpViewState;
/**
* Date: 19.12.2015
* Time: 14:54
*
* @author Yuri Shmakov
*/
public final class DefaultViewState extends MvpViewState<MvpView> {
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/DefaultViewState.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 67 |
```java
package com.arellomobile.mvp;
import java.util.HashMap;
import java.util.Map;
import android.util.Log;
/**
* Date: 17-Dec-15
* Time: 16:05
*
* @author Yuri Shmakov
* @author Alexander Blinov
*/
@SuppressWarnings("WeakerAccess")
public class PresenterStore {
private Map<String, MvpPresenter> mPresenters = new HashMap<>();
/**
* Add presenter to storage
*
* @param tag Tag of presenter. Local presenters contains also delegate's tag as prefix
* @param instance Instance of MvpPresenter implementation to store
* @param <T> Type of presenter
*/
public <T extends MvpPresenter> void add(String tag, T instance) {
mPresenters.put(tag, instance);
}
/**
* Get presenter on existing params
*
* @param tag Tag of presenter. Local presenters contains also delegate's tag as prefix
* @return Presenter if it's exists. Null otherwise (if it's no exists)
*/
public MvpPresenter get(String tag) {
return mPresenters.get(tag);
}
/**
* Remove presenter from store.
*
* @param tag Tag of presenter. Local presenters contains also delegate's tag as prefix
* @return Presenter which was removed
*/
public MvpPresenter remove(String tag) {
return mPresenters.remove(tag);
}
public void logPresenters() {
for (Map.Entry<String, MvpPresenter> currentEntry : mPresenters.entrySet()) {
Log.d("PresenterStore", currentEntry.getKey() + " -> " +
currentEntry.getValue());
}
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/PresenterStore.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 366 |
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package com.arellomobile.mvp;
/**
* Container to ease passing around a tuple of two objects. This object provides a sensible
* implementation of equals(), returning true if equals() is true on each of the contained
* objects.
*/
public class Pair<F, S> {
public final F first;
public final S second;
/**
* Constructor for a Pair.
*
* @param first the first object in the Pair
* @param second the second object in the pair
*/
public Pair(F first, S second) {
this.first = first;
this.second = second;
}
/**
* Checks the two objects for equality by delegating to their respective
* {@link Object#equals(Object)} methods.
*
* @param o the {@link Pair} to which this one is to be checked for equality
* @return true if the underlying objects of the Pair are both considered
* equal
*/
@Override
public boolean equals(Object o) {
if (!(o instanceof Pair)) {
return false;
}
Pair<?, ?> p = (Pair<?, ?>) o;
return objectsEqual(p.first, first) && objectsEqual(p.second, second);
}
private static boolean objectsEqual(Object a, Object b) {
return (a == null) ? (b == null) : a.equals(b);
}
/**
* Compute a hash code using the hash codes of the underlying objects
*
* @return a hashcode of the Pair
*/
@Override
public int hashCode() {
return (first == null ? 0 : first.hashCode()) ^ (second == null ? 0 : second.hashCode());
}
/**
* Convenience method for creating an appropriately typed pair.
*
* @param <A> first entry type
* @param <B> second entry type
* @param a the first object in the Pair
* @param b the second object in the pair
* @return a Pair that is templatized with the types of a and b
*/
public static <A, B> Pair<A, B> create(A a, B b) {
return new Pair<A, B>(a, b);
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/Pair.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 517 |
```java
package com.arellomobile.mvp.viewstate;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import com.arellomobile.mvp.MvpView;
/**
* Date: 15.12.2015
* Time: 19:58
*
* @author Yuri Shmakov
*/
@SuppressWarnings("WeakerAccess")
public abstract class MvpViewState<View extends MvpView> {
protected ViewCommands<View> mViewCommands = new ViewCommands<>();
protected Set<View> mViews;
protected Set<View> mInRestoreState;
protected Map<View, Set<ViewCommand<View>>> mViewStates;
public MvpViewState() {
mViews = Collections.newSetFromMap(new WeakHashMap<View, Boolean>());
mInRestoreState = Collections.newSetFromMap(new WeakHashMap<View, Boolean>());
mViewStates = new WeakHashMap<>();
}
/**
* Apply saved state to attached view
*
* @param view mvp view to restore state
* @param currentState commands that was applied already
*/
protected void restoreState(View view, Set<ViewCommand<View>> currentState) {
if (mViewCommands.isEmpty()) {
return;
}
mViewCommands.reapply(view, currentState);
}
/**
* Attach view to view state and apply saves state
*
* @param view attachment
*/
public void attachView(View view) {
if (view == null) {
throw new IllegalArgumentException("Mvp view must be not null");
}
boolean isViewAdded = mViews.add(view);
if (!isViewAdded) {
return;
}
mInRestoreState.add(view);
Set<ViewCommand<View>> currentState = mViewStates.get(view);
currentState = currentState == null ? Collections.<ViewCommand<View>>emptySet() : currentState;
restoreState(view, currentState);
mViewStates.remove(view);
mInRestoreState.remove(view);
}
/**
* <p>Detach view from view state. After this moment view state save
* commands via
* {@link com.arellomobile.mvp.viewstate.strategy.StateStrategy#beforeApply(List, ViewCommand)}.</p>
*
* @param view target mvp view to detach
*/
public void detachView(View view) {
mViews.remove(view);
mInRestoreState.remove(view);
Set<ViewCommand<View>> currentState = Collections.newSetFromMap(new WeakHashMap<ViewCommand<View>, Boolean>());
currentState.addAll(mViewCommands.getCurrentState());
mViewStates.put(view, currentState);
}
public void destroyView(View view) {
mViewStates.remove(view);
}
/**
* @return views, attached to this view state instance
*/
public Set<View> getViews() {
return mViews;
}
/**
* Check if view is in restore state or not
*
* @param view view for check
* @return true if view state restore state to incoming view. false otherwise.
*/
public boolean isInRestoreState(View view) {
return mInRestoreState.contains(view);
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/viewstate/MvpViewState.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 662 |
```java
package com.arellomobile.mvp.viewstate;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.strategy.StateStrategy;
/**
* Date: 16-Dec-15
* Time: 16:59
*
* @author Alexander Blinov
*/
public abstract class ViewCommand<View extends MvpView> {
private final String mTag;
private final Class<? extends StateStrategy> mStateStrategyType;
protected ViewCommand(String tag, Class<? extends StateStrategy> stateStrategyType) {
mTag = tag;
mStateStrategyType = stateStrategyType;
}
public abstract void apply(View view);
public String getTag() {
return mTag;
}
public Class<? extends StateStrategy> getStrategyType() {
return mStateStrategyType;
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/viewstate/ViewCommand.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 171 |
```java
package com.arellomobile.mvp.viewstate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.arellomobile.mvp.MoxyReflector;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.strategy.StateStrategy;
/**
* Date: 17.12.2015
* Time: 11:09
*
* @author Yuri Shmakov
*/
@SuppressWarnings({"unused", "WeakerAccess"})
public class ViewCommands<View extends MvpView> {
private List<ViewCommand<View>> mState = new ArrayList<>();
private Map<Class<? extends StateStrategy>, StateStrategy> mStrategies = new HashMap<>();
public void beforeApply(ViewCommand<View> viewCommand) {
StateStrategy stateStrategy = getStateStrategy(viewCommand);
stateStrategy.beforeApply(mState, viewCommand);
}
public void afterApply(ViewCommand<View> viewCommand) {
StateStrategy stateStrategy = getStateStrategy(viewCommand);
stateStrategy.afterApply(mState, viewCommand);
}
private StateStrategy getStateStrategy(ViewCommand<View> viewCommand) {
StateStrategy stateStrategy = (StateStrategy) MoxyReflector.getStrategy(viewCommand.getStrategyType());
if (stateStrategy == null) {
//noinspection TryWithIdenticalCatches
try {
stateStrategy = viewCommand.getStrategyType().newInstance();
} catch (InstantiationException e) {
throw new IllegalArgumentException("Unable to create state strategy: " + viewCommand.toString());
} catch (IllegalAccessException e) {
throw new IllegalArgumentException("Unable to create state strategy: " + viewCommand.toString());
}
mStrategies.put(viewCommand.getStrategyType(), stateStrategy);
}
return stateStrategy;
}
public boolean isEmpty() {
return mState.isEmpty();
}
public void reapply(View view, Set<ViewCommand<View>> currentState) {
final ArrayList<ViewCommand<View>> commands = new ArrayList<>(mState);
for (ViewCommand<View> command : commands) {
if (currentState.contains(command)) {
continue;
}
command.apply(view);
afterApply(command);
}
}
public List<ViewCommand<View>> getCurrentState() {
return mState;
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/viewstate/ViewCommands.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 476 |
```java
package com.arellomobile.mvp.viewstate.strategy;
import java.util.List;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.ViewCommand;
/**
* This strategy will clear current commands queue and then incoming command will be put in.
*
* Caution! Be sure that you fully set view to initial state inside this command.
*
* Date: 19-Dec-15
* Time: 14:34
*
* @author Alexander Blinov
*/
public class SingleStateStrategy implements StateStrategy {
@Override
public <View extends MvpView> void beforeApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand) {
currentState.clear();
currentState.add(incomingCommand);
}
@Override
public <View extends MvpView> void afterApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand) {
// pass
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/viewstate/strategy/SingleStateStrategy.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 195 |
```java
package com.arellomobile.mvp.viewstate.strategy;
import java.util.Iterator;
import java.util.List;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.ViewCommand;
/**
* Command will be added to end of commands queue. If commands queue contains same type command, then existing command will be removed.
*
* Date: 17.12.2015
* Time: 11:24
*
* @author Yuri Shmakov
*/
public class AddToEndSingleStrategy implements StateStrategy {
@Override
public <View extends MvpView> void beforeApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand) {
Iterator<ViewCommand<View>> iterator = currentState.iterator();
while (iterator.hasNext()) {
ViewCommand<View> entry = iterator.next();
if (entry.getClass() == incomingCommand.getClass()) {
iterator.remove();
break;
}
}
currentState.add(incomingCommand);
}
@Override
public <View extends MvpView> void afterApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand) {
// pass
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/viewstate/strategy/AddToEndSingleStrategy.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 242 |
```java
package com.arellomobile.mvp.viewstate.strategy;
import java.util.List;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.ViewCommand;
/**
* Command will be saved in commands queue. And this command will be removed after first execution.
*
* Date: 24.11.2016
* Time: 11:48
*
* @author Yuri Shmakov
*/
public class OneExecutionStateStrategy implements StateStrategy {
@Override
public <View extends MvpView> void beforeApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand) {
currentState.add(incomingCommand);
}
@Override
public <View extends MvpView> void afterApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand) {
currentState.remove(incomingCommand);
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/viewstate/strategy/OneExecutionStateStrategy.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 179 |
```java
package com.arellomobile.mvp;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import android.os.Bundle;
import com.arellomobile.mvp.presenter.PresenterType;
/**
* Date: 18-Dec-15
* Time: 13:51
* <p>
* This class represents a delegate which you can use to extend Mvp's support to any class.
* <p>
* When using an {@link MvpDelegate}, lifecycle methods which should be proxied to the delegate:
* <ul>
* <li>{@link #onCreate(Bundle)}</li>
* <li>{@link #onAttach()}: inside onStart() of Activity or Fragment</li>
* <li>{@link #onSaveInstanceState(android.os.Bundle)}</li>
* <li>{@link #onDetach()}: inside onDestroy() for Activity or onDestroyView() for Fragment</li>
* <li>{@link #onDestroy()}</li>
* </ul>
* <p>
* Every {@link Object} can only be linked with one {@link MvpDelegate} instance,
* so the instance returned from {@link #MvpDelegate(Object)}} should be kept
* until the Object is destroyed.
*
* @author Yuri Shmakov
* @author Alexander Blinov
* @author Konstantin Tckhovrebov
*/
public class MvpDelegate<Delegated> {
private static final String KEY_TAG = "com.arellomobile.mvp.MvpDelegate.KEY_TAG";
public static final String MOXY_DELEGATE_TAGS_KEY = "MoxyDelegateBundle";
private String mKeyTag = KEY_TAG;
private String mDelegateTag;
private final Delegated mDelegated;
private boolean mIsAttached;
private MvpDelegate mParentDelegate;
private List<MvpPresenter<? super Delegated>> mPresenters;
private List<MvpDelegate> mChildDelegates;
private Bundle mBundle;
public MvpDelegate(Delegated delegated) {
mDelegated = delegated;
mChildDelegates = new ArrayList<>();
}
public void setParentDelegate(MvpDelegate delegate, String childId) {
if (mBundle != null) {
throw new IllegalStateException("You should call setParentDelegate() before first onCreate()");
}
if (mChildDelegates != null && mChildDelegates.size() > 0) {
throw new IllegalStateException("You could not set parent delegate when there are already has child presenters");
}
mParentDelegate = delegate;
mKeyTag = mParentDelegate.mKeyTag + "$" + childId;
delegate.addChildDelegate(this);
}
private void addChildDelegate(MvpDelegate delegate) {
mChildDelegates.add(delegate);
}
private void removeChildDelegate(MvpDelegate delegate) {
mChildDelegates.remove(delegate);
}
/**
* Free self link from children list (mChildDelegates) in parent delegate
* property mParentDelegate stay keep link to parent delegate for access to
* parent bundle for save state in {@link #onSaveInstanceState()}
*/
public void freeParentDelegate() {
if (mParentDelegate == null) {
throw new IllegalStateException("You should call freeParentDelegate() before first setParentDelegate()");
}
mParentDelegate.removeChildDelegate(this);
}
public void removeAllChildDelegates()
{
// For avoiding ConcurrentModificationException when removing by removeChildDelegate()
List<MvpDelegate> childDelegatesClone = new ArrayList<MvpDelegate>(mChildDelegates.size());
childDelegatesClone.addAll(mChildDelegates);
for (MvpDelegate childDelegate : childDelegatesClone) {
childDelegate.freeParentDelegate();
}
mChildDelegates = new ArrayList<>();
}
/**
* <p>Similar like {@link #onCreate(Bundle)}. But this method try to get saved
* state from parent presenter before get presenters</p>
*/
public void onCreate() {
Bundle bundle = new Bundle();
if (mParentDelegate != null) {
bundle = mParentDelegate.mBundle;
}
onCreate(bundle);
}
/**
* <p>Get(or create if not exists) presenters for delegated object and bind
* them to this object fields</p>
*
* @param bundle with saved state
*/
public void onCreate(Bundle bundle) {
if (mParentDelegate == null && bundle != null) {
bundle = bundle.getBundle(MOXY_DELEGATE_TAGS_KEY);
}
mIsAttached = false;
mBundle = bundle != null ? bundle : new Bundle();
//get base tag for presenters
if (bundle == null || !mBundle.containsKey(mKeyTag)) {
mDelegateTag = generateTag();
} else {
mDelegateTag = bundle.getString(mKeyTag);
}
//bind presenters to view
mPresenters = MvpFacade.getInstance().getMvpProcessor().getMvpPresenters(mDelegated, mDelegateTag);
for (MvpDelegate childDelegate : mChildDelegates) {
childDelegate.onCreate(bundle);
}
}
/**
* <p>Attach delegated object as view to presenter fields of this object.
* If delegate did not enter at {@link #onCreate(Bundle)}(or
* {@link #onCreate()}) before this method, then view will not be attached to
* presenters</p>
*/
public void onAttach() {
for (MvpPresenter<? super Delegated> presenter : mPresenters) {
if (mIsAttached && presenter.getAttachedViews().contains(mDelegated)) {
continue;
}
presenter.attachView(mDelegated);
}
for (MvpDelegate<?> childDelegate : mChildDelegates) {
childDelegate.onAttach();
}
mIsAttached = true;
}
/**
* <p>Detach delegated object from their presenters.</p>
*/
public void onDetach() {
for (MvpPresenter<? super Delegated> presenter : mPresenters) {
if (!mIsAttached && !presenter.getAttachedViews().contains(mDelegated)) {
continue;
}
presenter.detachView(mDelegated);
}
mIsAttached = false;
for (MvpDelegate<?> childDelegate : mChildDelegates) {
childDelegate.onDetach();
}
}
/**
* <p>View was being destroyed, but logical unit still alive</p>
*/
public void onDestroyView() {
for (MvpPresenter<? super Delegated> presenter : mPresenters) {
presenter.destroyView(mDelegated);
}
// For avoiding ConcurrentModificationException when removing from mChildDelegates
List<MvpDelegate> childDelegatesClone = new ArrayList<MvpDelegate>(mChildDelegates.size());
childDelegatesClone.addAll(mChildDelegates);
for (MvpDelegate childDelegate : childDelegatesClone) {
childDelegate.onDestroyView();
}
if (mParentDelegate != null) {
freeParentDelegate();
}
}
/**
* <p>Destroy presenters.</p>
*/
public void onDestroy() {
PresentersCounter presentersCounter = MvpFacade.getInstance().getPresentersCounter();
PresenterStore presenterStore = MvpFacade.getInstance().getPresenterStore();
Set<MvpPresenter> allChildPresenters = presentersCounter.getAll(mDelegateTag);
for (MvpPresenter presenter : allChildPresenters) {
boolean isRejected = presentersCounter.rejectPresenter(presenter, mDelegateTag);
if (isRejected && presenter.getPresenterType() != PresenterType.GLOBAL) {
presenterStore.remove(presenter.getTag());
presenter.onDestroy();
}
}
}
/**
* <p>Similar like {@link #onSaveInstanceState(Bundle)}. But this method try to save
* state to parent presenter Bundle</p>
*/
public void onSaveInstanceState() {
Bundle bundle = new Bundle();
if (mParentDelegate != null && mParentDelegate.mBundle != null) {
bundle = mParentDelegate.mBundle;
}
onSaveInstanceState(bundle);
}
/**
* Save presenters tag prefix to save state for restore presenters at future after delegate recreate
*
* @param outState out state from Android component
*/
public void onSaveInstanceState(Bundle outState) {
if (mParentDelegate == null) {
Bundle moxyDelegateBundle = new Bundle();
outState.putBundle(MOXY_DELEGATE_TAGS_KEY, moxyDelegateBundle);
outState = moxyDelegateBundle;
}
outState.putAll(mBundle);
outState.putString(mKeyTag, mDelegateTag);
for (MvpDelegate childDelegate : mChildDelegates) {
childDelegate.onSaveInstanceState(outState);
}
}
public Bundle getChildrenSaveState() {
return mBundle;
}
/**
* @return generated tag in format: <parent_delegate_tag> <delegated_class_full_name>$MvpDelegate@<hashCode>
* <p>
* example: com.arellomobile.mvp.sample.SampleFragment$MvpDelegate@32649b0
*/
private String generateTag() {
String tag = mParentDelegate != null ? mParentDelegate.mDelegateTag + " " : "";
tag += mDelegated.getClass().getSimpleName() + "$" + getClass().getSimpleName() + toString().replace(getClass().getName(), "");
return tag;
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/MvpDelegate.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 2,055 |
```java
package com.arellomobile.mvp.viewstate.strategy;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Date: 16-Dec-15
* Time: 17:07
*
* @author Yuri Shmakov
* @author Alexander Blinov
*/
@Target(value = {ElementType.TYPE, ElementType.METHOD})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface StateStrategyType {
Class<? extends StateStrategy> value();
String tag() default "";
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/viewstate/strategy/StateStrategyType.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 117 |
```java
package com.arellomobile.mvp.viewstate.strategy;
import java.util.List;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.ViewCommand;
/**
* Command will not be put in commands queue
*
* Date: 21-Dec-15
* Time: 17:43
*
* @author Alexander Blinov
*/
public class SkipStrategy implements StateStrategy {
@Override
public <View extends MvpView> void beforeApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand) {
//do nothing to skip
}
@Override
public <View extends MvpView> void afterApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand) {
// pass
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/viewstate/strategy/SkipStrategy.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 163 |
```java
package com.arellomobile.mvp.viewstate.strategy;
import java.util.List;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.ViewCommand;
/**
* Command will be added to end of commands queue.
*
* This strategy used by default.
*
* Date: 17.12.2015
* Time: 11:29
*
* @author Yuri Shmakov
*/
public class AddToEndStrategy implements StateStrategy {
@Override
public <View extends MvpView> void beforeApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand) {
currentState.add(incomingCommand);
}
@Override
public <View extends MvpView> void afterApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand) {
// pass
}
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/viewstate/strategy/AddToEndStrategy.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 175 |
```java
package com.arellomobile.mvp.presenter;
import com.arellomobile.mvp.*;
/**
* Date: 18-Dec-15
* Time: 17:50
*
* @author Alexander Blinov
* @author Yuri Shmakov
*/
public abstract class PresenterField<PresentersContainer> {
protected final String tag;
protected final PresenterType presenterType;
protected final String presenterId;
protected final Class<? extends MvpPresenter<?>> presenterClass;
protected PresenterField(String tag, PresenterType presenterType, String presenterId, Class<? extends MvpPresenter<?>> presenterClass) {
this.tag = tag;
this.presenterType = presenterType;
this.presenterId = presenterId;
this.presenterClass = presenterClass;
}
public abstract void bind(PresentersContainer container, MvpPresenter presenter);
// Delegated may be used from generated code if user plane to generate tag at runtime
@SuppressWarnings("UnusedParameters")
public String getTag(PresentersContainer delegated) {
return tag;
}
public PresenterType getPresenterType() {
return presenterType;
}
public String getPresenterId() {
return presenterId;
}
public Class<? extends MvpPresenter<?>> getPresenterClass() {
return presenterClass;
}
public abstract MvpPresenter<?> providePresenter(PresentersContainer delegated);
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/presenter/PresenterField.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 275 |
```java
package com.arellomobile.mvp.viewstate.strategy;
import java.util.List;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.ViewCommand;
/**
* Cautions:
* <ul>
* <li>Don't rearrange current state</li>
* <li>Don't insert commands inside existing current state only put to end of it</li>
* <li>Be careful if remove commands by another type. If you make it, be sure that inside your view method you fully override view changes</li>
* </ul>
*
* Date: 17.12.2015
* Time: 11:21
*
* @author Yuri Shmakov
*/
public interface StateStrategy {
/**
* Called immediately after
* {@link com.arellomobile.mvp.viewstate.MvpViewState} receive some
* command. Will not be called before re-apply to some other
* {@link MvpView}
*
* @param currentState current state of
* {@link com.arellomobile.mvp.viewstate.MvpViewState}. Each {@link ViewCommand}
* contains self parameters.
* @param incomingCommand command for apply to {@link MvpView} This
* {@link ViewCommand} contains params of this command.
* @param <View> type of incoming view
*/
<View extends MvpView> void beforeApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand);
/**
* Called immediately after command applied to {@link MvpView}. Also called
* after re-apply to other views.
*
* @param currentState current state of
* {@link com.arellomobile.mvp.viewstate.MvpViewState}. Each {@link ViewCommand}
* contains self parameters.
* @param incomingCommand applied command to {@link MvpView} This
* {@link ViewCommand} contains params of this command.
* @param <View> type of incoming view
*/
<View extends MvpView> void afterApply(List<ViewCommand<View>> currentState, ViewCommand<View> incomingCommand);
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/viewstate/strategy/StateStrategy.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 466 |
```java
package com.arellomobile.mvp.presenter;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.arellomobile.mvp.MvpPresenter;
/**
* <p>Called when Moxy generate presenter tag for search Presenter in {@link com.arellomobile.mvp.PresenterStore}.</p>
* <p>Requirements:</p>
* <ul>
* <li>presenterClass parameter should be equals with presenter field type</li>
* <li>Presenter Types should be same</li>
* <li>Presenter IDs should be equals</li>
* </ul>
* <p>Note: if this method stay unused after build, then Moxy never use this method and you should check annotation parameters.</p>
* <br>
* Date: 14.10.2016
* Time: 00:09
*
* @author Yuri Shmakov
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ProvidePresenterTag {
String EMPTY = "";
Class<? extends MvpPresenter<?>> presenterClass();
PresenterType type() default PresenterType.LOCAL;
String presenterId() default EMPTY;
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/presenter/ProvidePresenterTag.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 254 |
```java
package com.arellomobile.mvp.presenter;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Called when Moxy can't find right presenter instance in {@link com.arellomobile.mvp.PresenterStore}.
* <p>Attention! <b>Don't use manually method marked with this annotation!</b> Use presenter field, which you want. If you override this method in inherited classes, make them return same type(not requirements but recommendation).</p>
* <p>Requirements:</p>
* <ul>
* <li>Method should return full equals class as presenter field type</li>
* <li>Presenter Types should be same</li>
* <li>Tags should be equals</li>
* <li>Presenter IDs should be equals</li>
* </ul>
* <p>Note: if this method stay unused after build, then Moxy never use this method and you should check annotation parameters. These parameters should be equals to @InjectPresenter parameters</p>
* <br>
* Date: 14.10.2016
* Time: 00:09
*
* @author Yuri Shmakov
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ProvidePresenter {
String EMPTY = "";
String tag() default EMPTY;
PresenterType type() default PresenterType.LOCAL;
String presenterId() default EMPTY;
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/presenter/ProvidePresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 303 |
```java
package com.arellomobile.mvp.presenter;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Date: 17.12.2015
* Time: 14:54
*
* @author Yuri Shmakov
* @author Alexander BLinov
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InjectPresenter {
String EMPTY = "";
String tag() default EMPTY;
PresenterType type() default PresenterType.LOCAL;
String presenterId() default EMPTY;
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/presenter/InjectPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 124 |
```java
package com.arellomobile.mvp.presenter;
import com.arellomobile.mvp.MvpPresenter;
/**
* Available presenter types. Manually lifetime control are available over {@link com.arellomobile.mvp.PresenterStore}, {@link com.arellomobile.mvp.PresentersCounter} and {@link MvpPresenter#onDestroy()}
* <p>
* Date: 17-Dec-15
* Time: 19:31
*
* @author Yuri Shmakov
* @author Alexander Blinov
*/
public enum PresenterType {
/**
* Local presenter are not available out of injectable object
*/
LOCAL,
/**
* Weak presenters are available everywhere. Weak presenter will be destroyed when finished all views. Inject will create new presenter instance.
*/
WEAK,
/**
* Global presenter will be destroyed only when process will be killed({@link MvpPresenter#onDestroy()} won't be called)
*/
GLOBAL
}
``` | /content/code_sandbox/moxy/src/main/java/com/arellomobile/mvp/presenter/PresenterType.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 203 |
```qmake
# Add project specific ProGuard rules here.
# By default, the flags in this file are appended to flags specified
# in C:\Development\Programs\Android\android-sdk/tools/proguard/proguard-android.txt
# You can edit the include path and order by changing the proguardFiles
# directive in build.gradle.
#
# For more details, see
# path_to_url
# Add any project specific keep options here:
# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
# public *;
#}
``` | /content/code_sandbox/sample-github/proguard-rules.pro | qmake | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 143 |
```java
package com.arellomobile.mvp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Date: 07.12.2016
* Time: 16:39
*
* @author Yuri Shmakov
*/
public class MoxyReflector {
private static Map<Class<?>, Object> sViewStateProviders;
private static Map<Class<?>, List<Object>> sPresenterBinders;
private static Map<Class<?>, Object> sStrategies;
static {
sViewStateProviders = new HashMap<>();
sPresenterBinders = new HashMap<>();
}
public static Object getViewState(Class<?> presenterClass) {
return sViewStateProviders.get(presenterClass);
}
public static List<Object> getPresenterBinders(Class<?> delegated) {
return sPresenterBinders.get(delegated);
}
public static Object getStrategy(Class strategyClass) {
return sStrategies.get(strategyClass);
}
}
``` | /content/code_sandbox/moxy/stub-reflector/src/main/java/com/arellomobile/mvp/MoxyReflector.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 192 |
```java
package com.arellomobile.mvp.sample.github.test;
import android.content.Context;
import com.arellomobile.mvp.sample.github.di.AppComponent;
import com.arellomobile.mvp.sample.github.mvp.GithubService;
import com.arellomobile.mvp.sample.github.mvp.presenters.RepositoriesPresenter;
import com.arellomobile.mvp.sample.github.mvp.presenters.RepositoryLikesPresenter;
import com.arellomobile.mvp.sample.github.mvp.presenters.SignInPresenter;
import com.squareup.otto.Bus;
import org.robolectric.RuntimeEnvironment;
public class TestComponent implements AppComponent {
@Override
public Context getContext() {
return RuntimeEnvironment.application;
}
@Override
public GithubService getAuthService() {
return null;
}
@Override
public Bus getBus() {
return null;
}
@Override
public void inject(SignInPresenter presenter) {
}
@Override
public void inject(RepositoriesPresenter repositoriesPresenter) {
}
@Override
public void inject(RepositoryLikesPresenter repositoryLikesPresenter) {
}
}
``` | /content/code_sandbox/sample-github/src/test/java/com/arellomobile/mvp/sample/github/test/TestComponent.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 208 |
```java
package com.arellomobile.mvp.sample.github.test;
import java.lang.reflect.Method;
import android.support.annotation.NonNull;
import com.arellomobile.mvp.sample.github.BuildConfig;
import org.junit.runners.model.InitializationError;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
public class GithubSampleTestRunner extends RobolectricTestRunner {
private static final int SDK_EMULATE_LEVEL = 23;
public GithubSampleTestRunner(Class<?> testClass) throws InitializationError {
super(testClass);
}
@Override
public Config getConfig(@NonNull Method method) {
final Config defaultConfig = super.getConfig(method);
return new Config.Implementation(
new int[]{SDK_EMULATE_LEVEL},
defaultConfig.manifest(),
defaultConfig.qualifiers(),
defaultConfig.packageName(),
defaultConfig.resourceDir(),
defaultConfig.assetDir(),
defaultConfig.shadows(),
defaultConfig.instrumentedPackages(),
defaultConfig.application(),
defaultConfig.libraries(),
defaultConfig.constants() == Void.class ? BuildConfig.class : defaultConfig.constants()
);
}
}
``` | /content/code_sandbox/sample-github/src/test/java/com/arellomobile/mvp/sample/github/test/GithubSampleTestRunner.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 225 |
```java
package com.arellomobile.mvp.sample.github.test;
import android.support.annotation.NonNull;
import com.arellomobile.mvp.sample.github.app.GithubApp;
import com.arellomobile.mvp.sample.github.di.AppComponent;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
public class TestComponentRule implements TestRule {
private AppComponent appComponent;
public TestComponentRule() {
appComponent = new TestComponent();
}
public TestComponentRule(@NonNull AppComponent component) {
this.appComponent = component;
}
@Override
public Statement apply(Statement base, Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
GithubApp.setAppComponent(appComponent);
base.evaluate();
}
};
}
}
``` | /content/code_sandbox/sample-github/src/test/java/com/arellomobile/mvp/sample/github/test/TestComponentRule.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 168 |
```java
package com.arellomobile.mvp.sample.github.mvp.presenters;
import com.arellomobile.mvp.sample.github.mvp.common.AuthUtils;
import com.arellomobile.mvp.sample.github.mvp.views.SplashView;
import com.arellomobile.mvp.sample.github.test.GithubSampleTestRunner;
import com.arellomobile.mvp.sample.github.test.TestComponentRule;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static org.mockito.Mockito.verify;
@RunWith(GithubSampleTestRunner.class)
public class SplashPresenterTest {
@Rule
public TestComponentRule testComponentRule = new TestComponentRule();
@Mock
SplashView splashView;
private SplashPresenter presenter;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
presenter = new SplashPresenter();
presenter.getAttachedViews().add(splashView);
}
@Test
public void splash_shouldAuthorizedStateFalse() {
AuthUtils.setToken(null);
presenter.attachView(splashView);
verify(splashView).setAuthorized(false);
}
@Test
public void splash_shouldAuthorizedStateTrue() {
AuthUtils.setToken("token");
presenter.attachView(splashView);
verify(splashView).setAuthorized(true);
}
}
``` | /content/code_sandbox/sample-github/src/test/java/com/arellomobile/mvp/sample/github/mvp/presenters/SplashPresenterTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 281 |
```java
package com.arellomobile.mvp.sample.github.mvp.presenters;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.sample.github.mvp.views.HomeView;
import com.arellomobile.mvp.sample.github.mvp.views.HomeView$$State;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static org.mockito.Mockito.verify;
public final class HomePresenterTest {
@Mock
HomeView homeView;
@Mock
HomeView$$State homeViewState;
private HomePresenter presenter;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
presenter = new HomePresenter();
presenter.attachView(homeView);
presenter.setViewState(homeViewState);
}
@Test
public void details_shouldShowDetailsContainer() {
Repository emptyRepository = emptyRepository();
presenter.onRepositorySelection(0, emptyRepository);
verify(homeViewState).showDetailsContainer();
verify(homeViewState).showDetails(0, emptyRepository);
}
private Repository emptyRepository() {
return new Repository();
}
}
``` | /content/code_sandbox/sample-github/src/test/java/com/arellomobile/mvp/sample/github/mvp/presenters/HomePresenterTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 233 |
```java
package com.arellomobile.mvp.sample.github.mvp.presenters;
import java.util.ArrayList;
import java.util.List;
import com.arellomobile.mvp.sample.github.di.AppComponent;
import com.arellomobile.mvp.sample.github.mvp.GithubService;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.sample.github.mvp.views.RepositoriesView$$State;
import com.arellomobile.mvp.sample.github.test.GithubSampleTestRunner;
import com.arellomobile.mvp.sample.github.test.TestComponent;
import com.arellomobile.mvp.sample.github.test.TestComponentRule;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import rx.Observable;
import rx.Scheduler;
import rx.android.plugins.RxAndroidPlugins;
import rx.android.plugins.RxAndroidSchedulersHook;
import rx.plugins.RxJavaPlugins;
import rx.plugins.RxJavaSchedulersHook;
import rx.schedulers.Schedulers;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(GithubSampleTestRunner.class)
public class RepositoriesPresenterTest {
@Mock
GithubService githubService;
@Rule
public TestComponentRule testComponentRule = new TestComponentRule(testAppComponent());
@Mock
RepositoriesView$$State repositoriesViewState;
private RepositoriesPresenter presenter;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
presenter = new RepositoriesPresenter();
presenter.setViewState(repositoriesViewState);
RxJavaPlugins.getInstance().reset();
RxJavaPlugins.getInstance().registerSchedulersHook(new RxJavaSchedulersHook() {
@Override
public Scheduler getIOScheduler() {
return Schedulers.immediate();
}
});
RxAndroidPlugins.getInstance().reset();
RxAndroidPlugins.getInstance().registerSchedulersHook(new RxAndroidSchedulersHook() {
@Override
public Scheduler getMainThreadScheduler() {
return Schedulers.immediate();
}
});
}
@Test
public void repositories_shouldCloseError() {
presenter.onErrorCancel();
verify(repositoriesViewState).hideError();
}
@Test
public void repositories_shouldOnAttachLoadAndShowRepositores() {
List<Repository> repositories = repositores();
when(githubService.getUserRepos(anyString(), anyInt(), anyInt())).thenReturn(Observable.just(repositories));
presenter.onFirstViewAttach();
verify(repositoriesViewState).onStartLoading();
verify(repositoriesViewState, never()).showRefreshing();
verify(repositoriesViewState).showListProgress();
verify(repositoriesViewState).onFinishLoading();
verify(repositoriesViewState).setRepositories(repositories, false);
}
@Test
public void repositories_shouldCorrectLoadNextRepositories() {
List<Repository> repositories = repositores();
when(githubService.getUserRepos(anyString(), anyInt(), anyInt())).thenReturn(Observable.just(repositories));
presenter.loadNextRepositories(10);
verify(repositoriesViewState).onStartLoading();
verify(repositoriesViewState, never()).showListProgress();
verify(repositoriesViewState, never()).hideListProgress();
verify(repositoriesViewState).onFinishLoading();
verify(repositoriesViewState).addRepositories(repositories, false);
}
@Test
public void repositories_shouldShowErrorIfSomeExceptionHappended() {
RuntimeException someError = new RuntimeException();
when(githubService.getUserRepos(anyString(), anyInt(), anyInt())).thenReturn(Observable.error(someError));
presenter.loadNextRepositories(10);
verify(repositoriesViewState).onStartLoading();
verify(repositoriesViewState).onFinishLoading();
verify(repositoriesViewState).showError(someError.toString());
}
private List<Repository> repositores() {
List<Repository> repositories = new ArrayList<>();
for (int i = 0; i < 10; i++) {
repositories.add(new Repository());
}
return repositories;
}
private AppComponent testAppComponent() {
return new TestComponent() {
@Override
public void inject(RepositoriesPresenter presenter) {
presenter.mGithubService = githubService;
}
};
}
}
``` | /content/code_sandbox/sample-github/src/test/java/com/arellomobile/mvp/sample/github/mvp/presenters/RepositoriesPresenterTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 899 |
```java
package com.arellomobile.mvp.sample.github.mvp.presenters;
import java.util.Collections;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.sample.github.mvp.views.RepositoryView$$State;
import com.arellomobile.mvp.sample.github.test.GithubSampleTestRunner;
import com.arellomobile.mvp.sample.github.test.TestComponentRule;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
@RunWith(GithubSampleTestRunner.class)
public class RepositoryPresenterTest {
@Rule
public TestComponentRule testComponentRule = new TestComponentRule();
@Mock
RepositoryView$$State repositoryViewState;
private RepositoryPresenter presenter;
private Repository repository;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
repository = new Repository();
presenter = new RepositoryPresenter(repository);
presenter.setViewState(repositoryViewState);
}
@Test
public void repository_shouldShwRepository() {
presenter.onFirstViewAttach();
verify(repositoryViewState).showRepository(repository);
verify(repositoryViewState, never()).updateLike(anyBoolean(), anyBoolean());
}
@Test
public void repository_shouldSetLikeTrueForRepository() {
presenter.updateLikes(Collections.singletonList(0), Collections.singletonList(0));
verify(repositoryViewState).updateLike(true, true);
}
@Test
public void repository_shouldSetLikeFalseForRepository() {
presenter.updateLikes(Collections.singletonList(1), Collections.singletonList(1));
verify(repositoryViewState).updateLike(false, false);
}
}
``` | /content/code_sandbox/sample-github/src/test/java/com/arellomobile/mvp/sample/github/mvp/presenters/RepositoryPresenterTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 359 |
```java
package com.arellomobile.mvp.sample.github.mvp.presenters;
import com.arellomobile.mvp.sample.github.mvp.common.AuthUtils;
import com.arellomobile.mvp.sample.github.mvp.views.SignOutView$$State;
import com.arellomobile.mvp.sample.github.test.GithubSampleTestRunner;
import com.arellomobile.mvp.sample.github.test.TestComponentRule;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.verify;
@RunWith(GithubSampleTestRunner.class)
public final class SignOutPresenterTest {
@Rule
public TestComponentRule testComponentRule = new TestComponentRule();
@Mock
SignOutView$$State signOutViewState;
private SignOutPresenter presenter;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
presenter = new SignOutPresenter();
presenter.setViewState(signOutViewState);
AuthUtils.setToken("some token");
}
@Test
public void signout_shouldSingOut() {
presenter.signOut();
verify(signOutViewState).signOut();
assertEquals("", AuthUtils.getToken());
}
}
``` | /content/code_sandbox/sample-github/src/test/java/com/arellomobile/mvp/sample/github/mvp/presenters/SignOutPresenterTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 258 |
```java
package com.arellomobile.mvp.sample.github.mvp.presenters;
import java.util.concurrent.TimeUnit;
import android.content.Context;
import android.util.Base64;
import com.arellomobile.mvp.sample.github.R;
import com.arellomobile.mvp.sample.github.di.AppComponent;
import com.arellomobile.mvp.sample.github.mvp.GithubService;
import com.arellomobile.mvp.sample.github.mvp.common.AuthUtils;
import com.arellomobile.mvp.sample.github.mvp.models.User;
import com.arellomobile.mvp.sample.github.mvp.views.SignInView$$State;
import com.arellomobile.mvp.sample.github.test.GithubSampleTestRunner;
import com.arellomobile.mvp.sample.github.test.TestComponent;
import com.arellomobile.mvp.sample.github.test.TestComponentRule;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import rx.Observable;
import rx.Scheduler;
import rx.android.plugins.RxAndroidPlugins;
import rx.android.plugins.RxAndroidSchedulersHook;
import rx.plugins.RxJavaPlugins;
import rx.plugins.RxJavaSchedulersHook;
import rx.schedulers.Schedulers;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(GithubSampleTestRunner.class)
public final class SignInPresenterTest {
@Mock
GithubService githubService;
@Rule
public TestComponentRule testComponentRule = new TestComponentRule(testAppComponent());
@Mock
SignInView$$State signInViewState;
private SignInPresenter presenter;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
presenter = new SignInPresenter();
presenter.setViewState(signInViewState);
RxJavaPlugins.getInstance().reset();
RxJavaPlugins.getInstance().registerSchedulersHook(new RxJavaSchedulersHook() {
@Override
public Scheduler getIOScheduler() {
return Schedulers.immediate();
}
});
RxAndroidPlugins.getInstance().reset();
RxAndroidPlugins.getInstance().registerSchedulersHook(new RxAndroidSchedulersHook() {
@Override
public Scheduler getMainThreadScheduler() {
return Schedulers.immediate();
}
});
}
@Test
public void signin_shouldSignSuccessfull() {
String token = token();
when(githubService.signIn(token)).thenReturn(Observable.just(new User()));
presenter.signIn(email(), password());
try {
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
Assert.assertEquals(token, AuthUtils.getToken());
isSignInAndHideShowProgressCalled();
verify(signInViewState).successSignIn();
}
@Test
public void signin_shouldShowError() {
when(githubService.signIn(token())).thenReturn(Observable.error(new Throwable()));
presenter.signIn(email(), password());
try {
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
Assert.assertEquals("", "");
isSignInAndHideShowProgressCalled();
verify(signInViewState).failedSignIn(anyString());
}
@Test
public void signin_shouldShowPasswordAndEmailEmptyErros() {
presenter.signIn(null, null);
verify(signInViewState).showFormError(R.string.error_field_required, R.string.error_invalid_password);
}
@Test
public void signin_shouldOnErrorCancel() {
presenter.onErrorCancel();
verify(signInViewState).hideError();
}
private void isSignInAndHideShowProgressCalled() {
verify(signInViewState).hideFormError();
verify(signInViewState).startSignIn();
verify(signInViewState).finishSignIn();
verify(githubService).signIn(token());
}
private AppComponent testAppComponent() {
return new TestComponent() {
@Override
public Context getContext() {
return RuntimeEnvironment.application;
}
@Override
public void inject(SignInPresenter presenter) {
presenter.mGithubService = githubService;
}
};
}
private String token() {
String credentials = String.format("%s:%s", email(), password());
return "Basic " + Base64.encodeToString(credentials.getBytes(), Base64.NO_WRAP);
}
private String email() {
return "test@test.ru";
}
private String password() {
return "password";
}
}
``` | /content/code_sandbox/sample-github/src/test/java/com/arellomobile/mvp/sample/github/mvp/presenters/SignInPresenterTest.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 914 |
```java
package com.arellomobile.mvp.sample.github.ui.adapters;
import android.widget.BaseAdapter;
import com.arellomobile.mvp.MvpDelegate;
/**
* Date: 26.01.2016
* Time: 17:26
*
* @author Yuri Shmakov
*/
public abstract class MvpBaseAdapter extends BaseAdapter {
private MvpDelegate<? extends MvpBaseAdapter> mMvpDelegate;
private MvpDelegate<?> mParentDelegate;
private String mChildId;
public MvpBaseAdapter(MvpDelegate<?> parentDelegate, String childId) {
mParentDelegate = parentDelegate;
mChildId = childId;
getMvpDelegate().onCreate();
}
public MvpDelegate getMvpDelegate() {
if (mMvpDelegate == null) {
mMvpDelegate = new MvpDelegate<>(this);
mMvpDelegate.setParentDelegate(mParentDelegate, mChildId);
}
return mMvpDelegate;
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/ui/adapters/MvpBaseAdapter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 206 |
```java
package com.arellomobile.mvp.sample.github.ui.activities;
import android.app.AlertDialog;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.inputmethod.EditorInfo;
import android.widget.Button;
import android.widget.EditText;
import com.arellomobile.mvp.MvpAppCompatActivity;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.sample.github.R;
import com.arellomobile.mvp.sample.github.mvp.presenters.SignInPresenter;
import com.arellomobile.mvp.sample.github.mvp.views.SignInView;
import butterknife.BindView;
import butterknife.ButterKnife;
/**
* A login screen that offers login via email/password.
*/
public class SignInActivity extends MvpAppCompatActivity implements SignInView {
@InjectPresenter
SignInPresenter mSignInPresenter;
@BindView(R.id.email)
EditText mEmailView;
@BindView(R.id.password)
EditText mPasswordView;
@BindView(R.id.email_sign_in_button)
Button mSignInButton;
@BindView(R.id.login_form)
View mLoginFormView;
@BindView(R.id.login_progress)
View mProgressView;
private AlertDialog mErrorDialog;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sign_in);
ButterKnife.bind(this);
mPasswordView.setOnEditorActionListener((textView, id, keyEvent) -> {
if (id == R.id.login || id == EditorInfo.IME_NULL) {
attemptLogin();
return true;
}
return false;
});
mSignInButton.setOnClickListener(view -> attemptLogin());
}
private void attemptLogin() {
mSignInPresenter.signIn(mEmailView.getText().toString(), mPasswordView.getText().toString());
}
@Override
public void startSignIn() {
toggleProgressVisibility(true);
}
@Override
public void finishSignIn() {
toggleProgressVisibility(false);
}
private void toggleProgressVisibility(final boolean show) {
mProgressView.setVisibility(show ? View.VISIBLE : View.GONE);
mLoginFormView.setVisibility(show ? View.GONE : View.VISIBLE);
}
@Override
public void failedSignIn(String message) {
mErrorDialog = new AlertDialog.Builder(this)
.setTitle(R.string.app_name)
.setMessage(message)
.setOnCancelListener(dialog -> mSignInPresenter.onErrorCancel())
.show();
}
@Override
public void hideError() {
if (mErrorDialog != null && mErrorDialog.isShowing()) {
mErrorDialog.cancel();
}
}
@Override
public void hideFormError() {
mEmailView.setError(null);
mPasswordView.setError(null);
}
@Override
public void showFormError(Integer emailError, Integer passwordError) {
mEmailView.setError(emailError == null ? null : getString(emailError));
mPasswordView.setError(passwordError == null ? null : getString(passwordError));
}
@Override
public void successSignIn() {
final Intent intent = new Intent(this, SplashActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
}
@Override
protected void onDestroy() {
if (mErrorDialog != null && mErrorDialog.isShowing()) {
mErrorDialog.setOnCancelListener(null);
mErrorDialog.dismiss();
}
super.onDestroy();
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/ui/activities/SignInActivity.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 693 |
```java
package com.arellomobile.mvp.sample.github.ui.adapters;
import java.util.ArrayList;
import java.util.List;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageButton;
import android.widget.ProgressBar;
import android.widget.TextView;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.PresenterType;
import com.arellomobile.mvp.presenter.ProvidePresenter;
import com.arellomobile.mvp.sample.github.R;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.sample.github.mvp.presenters.RepositoryLikesPresenter;
import com.arellomobile.mvp.sample.github.mvp.presenters.RepositoryPresenter;
import com.arellomobile.mvp.sample.github.mvp.views.RepositoryLikesView;
import com.arellomobile.mvp.sample.github.mvp.views.RepositoryView;
import butterknife.BindView;
import butterknife.ButterKnife;
/**
* Date: 22.01.2016
* Time: 17:04
*
* @author Yuri Shmakov
*/
public class RepositoriesAdapter extends MvpBaseAdapter implements RepositoryLikesView {
public static final int REPOSITORY_VIEW_TYPE = 0;
private static final int PROGRESS_VIEW_TYPE = 1;
@InjectPresenter(type = PresenterType.WEAK, tag = RepositoryLikesPresenter.TAG)
RepositoryLikesPresenter mRepositoryLikesPresenter;
private int mSelection = -1;
private List<Repository> mRepositories;
private List<Integer> mLiked;
private List<Integer> mLikesInProgress;
private boolean mMaybeMore;
private OnScrollToBottomListener mScrollToBottomListener;
public RepositoriesAdapter(MvpDelegate<?> parentDelegate, OnScrollToBottomListener scrollToBottomListener) {
super(parentDelegate, String.valueOf(0));
mScrollToBottomListener = scrollToBottomListener;
mRepositories = new ArrayList<>();
mLiked = new ArrayList<>();
mLikesInProgress = new ArrayList<>();
}
public void setRepositories(List<Repository> repositories, boolean maybeMore) {
mRepositories = new ArrayList<>(repositories);
dataSetChanged(maybeMore);
}
public void addRepositories(List<Repository> repositories, boolean maybeMore) {
mRepositories.addAll(repositories);
dataSetChanged(maybeMore);
}
public void updateLikes(List<Integer> inProgress, List<Integer> likedIds) {
mLikesInProgress = new ArrayList<>(inProgress);
mLiked = new ArrayList<>(likedIds);
notifyDataSetChanged();
}
public void setSelection(int selection) {
mSelection = selection;
notifyDataSetChanged();
}
private void dataSetChanged(boolean maybeMore) {
mMaybeMore = maybeMore;
notifyDataSetChanged();
}
@Override
public int getItemViewType(int position) {
return position == mRepositories.size() ? PROGRESS_VIEW_TYPE : REPOSITORY_VIEW_TYPE;
}
@Override
public int getViewTypeCount() {
return 2;
}
public int getRepositoriesCount() {
return mRepositories.size();
}
@Override
public int getCount() {
return mRepositories.size() + (mMaybeMore ? 1 : 0);
}
@Override
public Repository getItem(int position) {
return mRepositories.get(position);
}
@Override
public long getItemId(int position) {
return getItem(position).getId();
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
if (getItemViewType(position) == PROGRESS_VIEW_TYPE) {
if (mScrollToBottomListener != null) {
mScrollToBottomListener.onScrollToBottom();
}
return new ProgressBar(parent.getContext());
}
RepositoryHolder holder;
if (convertView != null) {
holder = (RepositoryHolder) convertView.getTag();
} else {
convertView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_repository, parent, false);
holder = new RepositoryHolder(convertView);
convertView.setTag(holder);
}
final Repository item = getItem(position);
holder.bind(position, item);
return convertView;
}
public class RepositoryHolder implements RepositoryView {
@InjectPresenter
RepositoryPresenter mRepositoryPresenter;
private Repository mRepository;
@BindView(R.id.item_repository_text_view_name)
TextView nameTextView;
@BindView(R.id.item_repository_image_button_like)
ImageButton likeImageButton;
View view;
private MvpDelegate mMvpDelegate;
@ProvidePresenter
RepositoryPresenter provideRepositoryPresenter() {
return new RepositoryPresenter(mRepository);
}
RepositoryHolder(View view) {
this.view = view;
ButterKnife.bind(this, view);
}
void bind(int position, Repository repository) {
if (getMvpDelegate() != null) {
getMvpDelegate().onSaveInstanceState();
getMvpDelegate().onDetach();
getMvpDelegate().onDestroyView();
mMvpDelegate = null;
}
mRepository = repository;
getMvpDelegate().onCreate();
getMvpDelegate().onAttach();
view.setBackgroundResource(position == mSelection ? R.color.colorAccent : android.R.color.transparent);
likeImageButton.setOnClickListener(v -> mRepositoryLikesPresenter.toggleLike(repository.getId()));
boolean isInProgress = mLikesInProgress.contains(repository.getId());
likeImageButton.setEnabled(!isInProgress);
likeImageButton.setSelected(mLiked.contains(repository.getId()));
}
@Override
public void showRepository(Repository repository) {
nameTextView.setText(repository.getName());
}
@Override
public void updateLike(boolean isInProgress, boolean isLiked) {
// pass
}
MvpDelegate getMvpDelegate() {
if (mRepository == null) {
return null;
}
if (mMvpDelegate == null) {
mMvpDelegate = new MvpDelegate<>(this);
mMvpDelegate.setParentDelegate(RepositoriesAdapter.this.getMvpDelegate(), String.valueOf(mRepository.getId()));
}
return mMvpDelegate;
}
}
public interface OnScrollToBottomListener {
void onScrollToBottom();
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/ui/adapters/RepositoriesAdapter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 1,283 |
```java
package com.arellomobile.mvp.sample.github.ui.activities;
import android.content.Intent;
import android.os.Bundle;
import com.arellomobile.mvp.MvpAppCompatActivity;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.sample.github.mvp.presenters.SplashPresenter;
import com.arellomobile.mvp.sample.github.mvp.views.SplashView;
public class SplashActivity extends MvpAppCompatActivity implements SplashView {
@InjectPresenter
SplashPresenter mSplashPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// By default view attaches to presenter in onResume() method,
// but we attach it manually for earlier check authorization state.
getMvpDelegate().onAttach();
}
@Override
public void setAuthorized(boolean isAuthorized) {
startActivity(new Intent(this, isAuthorized ? HomeActivity.class : SignInActivity.class));
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/ui/activities/SplashActivity.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 187 |
```java
package com.arellomobile.mvp.sample.github.ui.views;
import android.content.Context;
import android.support.v4.widget.SwipeRefreshLayout;
import android.util.AttributeSet;
import android.widget.ListView;
/**
* Date: 26.01.2016
* Time: 14:54
*
* @author Yuri Shmakov
*/
public class FrameSwipeRefreshLayout extends SwipeRefreshLayout {
private ListView mListViewChild;
public FrameSwipeRefreshLayout(Context context) {
super(context);
}
public FrameSwipeRefreshLayout(Context context, AttributeSet attrs) {
super(context, attrs);
}
public void setListViewChild(ListView listViewChild) {
mListViewChild = listViewChild;
}
@Override
public boolean canChildScrollUp() {
if (mListViewChild != null && mListViewChild.getVisibility() == VISIBLE) {
return mListViewChild.canScrollVertically(-1);
}
return super.canChildScrollUp();
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/ui/views/FrameSwipeRefreshLayout.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 194 |
```java
package com.arellomobile.mvp.sample.github.ui.views;
import android.content.Context;
import android.os.Build;
import android.support.annotation.RequiresApi;
import android.util.AttributeSet;
import android.widget.TextView;
import com.arellomobile.mvp.MvpDelegate;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.ProvidePresenter;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.sample.github.mvp.presenters.RepositoryPresenter;
import com.arellomobile.mvp.sample.github.mvp.views.RepositoryView;
/**
* Created by senneco on 23.10.2016
*/
/**
* Date: 23.10.2016
* Time: 10:19
*
* @author Yuri Shmakov
*/
public class RepositoryWidget extends TextView implements RepositoryView {
private MvpDelegate mParentDelegate;
private MvpDelegate mMvpDelegate;
private Repository mRepository;
@InjectPresenter
RepositoryPresenter mRepositoryPresenter;
public RepositoryWidget(Context context) {
super(context);
}
public RepositoryWidget(Context context, AttributeSet attrs) {
super(context, attrs);
}
public RepositoryWidget(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
public RepositoryWidget(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
}
@ProvidePresenter
RepositoryPresenter provideRepositoryPresenter() {
return new RepositoryPresenter(mRepository);
}
public void initWidget(MvpDelegate parentDelegate, Repository repository) {
mParentDelegate = parentDelegate;
mRepository = repository;
getMvpDelegate().onCreate();
getMvpDelegate().onAttach();
}
public MvpDelegate getMvpDelegate() {
if (mMvpDelegate == null) {
mMvpDelegate = new MvpDelegate<>(this);
mMvpDelegate.setParentDelegate(mParentDelegate, String.valueOf(mRepository.getId()));
}
return mMvpDelegate;
}
@Override
public void showRepository(Repository repository) {
setText(repository.getName());
}
@Override
public void updateLike(boolean isInProgress, boolean isLiked) {
// pass
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/ui/views/RepositoryWidget.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 480 |
```java
package com.arellomobile.mvp.sample.github.ui.views;
import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build;
import android.util.AttributeSet;
import android.widget.Button;
import android.widget.Checkable;
/**
* Date: 26.01.2016
* Time: 17:19
*
* @author Yuri Shmakov
*/
public class LikeButton extends Button implements Checkable {
private boolean mChecked;
public LikeButton(Context context) {
super(context);
}
public LikeButton(Context context, AttributeSet attrs) {
super(context, attrs);
}
public LikeButton(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public LikeButton(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
}
@Override
public void setChecked(boolean checked) {
mChecked = checked;
}
@Override
public boolean isChecked() {
return mChecked;
}
@Override
public void toggle() {
mChecked = !mChecked;
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/ui/views/LikeButton.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 239 |
```java
package com.arellomobile.mvp.sample.github.ui.activities;
import java.util.List;
import android.app.AlertDialog;
import android.content.Intent;
import android.os.Bundle;
import android.support.v7.widget.Toolbar;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.TextView;
import com.arellomobile.mvp.MvpAppCompatActivity;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.sample.github.R;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.sample.github.mvp.presenters.HomePresenter;
import com.arellomobile.mvp.sample.github.mvp.presenters.RepositoriesPresenter;
import com.arellomobile.mvp.sample.github.mvp.presenters.SignOutPresenter;
import com.arellomobile.mvp.sample.github.mvp.views.HomeView;
import com.arellomobile.mvp.sample.github.mvp.views.RepositoriesView;
import com.arellomobile.mvp.sample.github.mvp.views.SignOutView;
import com.arellomobile.mvp.sample.github.ui.adapters.RepositoriesAdapter;
import com.arellomobile.mvp.sample.github.ui.fragments.DetailsFragment;
import com.arellomobile.mvp.sample.github.ui.views.FrameSwipeRefreshLayout;
import butterknife.BindView;
import butterknife.ButterKnife;
public class HomeActivity extends MvpAppCompatActivity implements SignOutView, RepositoriesView, HomeView, RepositoriesAdapter.OnScrollToBottomListener {
@InjectPresenter
SignOutPresenter mSignOutPresenter;
@InjectPresenter
RepositoriesPresenter mRepositoriesPresenter;
@InjectPresenter
HomePresenter mHomePresenter;
@BindView(R.id.activity_home_toolbar)
Toolbar mToolbar;
@BindView(R.id.activity_home_swipe_refresh_layout)
FrameSwipeRefreshLayout mSwipeRefreshLayout;
@BindView(R.id.activity_home_progress_bar_repositories)
ProgressBar mRepositoriesProgressBar;
@BindView(R.id.activity_home_list_view_repositories)
ListView mRepositoriesListView;
@BindView(R.id.activity_home_text_view_no_repositories)
TextView mNoRepositoriesTextView;
@BindView(R.id.activity_home_frame_layout_details)
FrameLayout mDetailsFragmeLayout;
private AlertDialog mErrorDialog;
private RepositoriesAdapter mRepositoriesAdapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_home);
ButterKnife.bind(this);
setSupportActionBar(mToolbar);
mSwipeRefreshLayout.setListViewChild(mRepositoriesListView);
mSwipeRefreshLayout.setOnRefreshListener(() -> mRepositoriesPresenter.loadRepositories(true));
mRepositoriesAdapter = new RepositoriesAdapter(getMvpDelegate(), this);
mRepositoriesListView.setAdapter(mRepositoriesAdapter);
mRepositoriesListView.setOnItemClickListener((parent, view, position, id) -> {
if (mRepositoriesAdapter.getItemViewType(position) != RepositoriesAdapter.REPOSITORY_VIEW_TYPE) {
return;
}
mHomePresenter.onRepositorySelection(position, mRepositoriesAdapter.getItem(position));
});
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.menu_home, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId() == R.id.menu_home_sign_out) {
mSignOutPresenter.signOut();
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
public void signOut() {
final Intent intent = new Intent(this, SplashActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
}
@Override
public void onStartLoading() {
mSwipeRefreshLayout.setEnabled(false);
}
@Override
public void onFinishLoading() {
mSwipeRefreshLayout.setEnabled(true);
}
@Override
public void showRefreshing() {
mSwipeRefreshLayout.post(() -> mSwipeRefreshLayout.setRefreshing(true));
}
@Override
public void hideRefreshing() {
mSwipeRefreshLayout.post(() -> mSwipeRefreshLayout.setRefreshing(false));
}
@Override
public void showListProgress() {
mRepositoriesListView.setVisibility(View.GONE);
mNoRepositoriesTextView.setVisibility(View.GONE);
mRepositoriesProgressBar.setVisibility(View.VISIBLE);
}
@Override
public void hideListProgress() {
mRepositoriesListView.setVisibility(View.VISIBLE);
mRepositoriesProgressBar.setVisibility(View.GONE);
}
@Override
public void showError(String message) {
mErrorDialog = new AlertDialog.Builder(this)
.setTitle(R.string.app_name)
.setMessage(message)
.setOnCancelListener(dialog -> mRepositoriesPresenter.onErrorCancel())
.show();
}
@Override
public void hideError() {
if (mErrorDialog != null && mErrorDialog.isShowing()) {
mErrorDialog.hide();
}
}
@Override
public void setRepositories(List<Repository> repositories, boolean maybeMore) {
mRepositoriesListView.setEmptyView(mNoRepositoriesTextView);
mRepositoriesAdapter.setRepositories(repositories, maybeMore);
}
@Override
public void addRepositories(List<Repository> repositories, boolean maybeMore) {
mRepositoriesListView.setEmptyView(mNoRepositoriesTextView);
mRepositoriesAdapter.addRepositories(repositories, maybeMore);
}
@Override
public void showDetailsContainer() {
if (mDetailsFragmeLayout.getVisibility() == View.GONE) {
mDetailsFragmeLayout.setVisibility(View.VISIBLE);
}
}
@Override
public void setSelection(int position) {
mRepositoriesAdapter.setSelection(position);
}
@Override
public void showDetails(int position, Repository repository) {
getSupportFragmentManager()
.beginTransaction()
.replace(R.id.activity_home_frame_layout_details, DetailsFragment.getInstance(repository))
.commit();
}
@Override
public void onScrollToBottom() {
mRepositoriesPresenter.loadNextRepositories(mRepositoriesAdapter.getRepositoriesCount());
}
@Override
protected void onDestroy() {
if (mErrorDialog != null && mErrorDialog.isShowing()) {
mErrorDialog.setOnCancelListener(null);
mErrorDialog.dismiss();
}
super.onDestroy();
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/ui/activities/HomeActivity.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 1,250 |
```java
package com.arellomobile.mvp.sample.github.common;
import rx.Observable;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;
/**
* Date: 11.01.2017
* Time: 16:39
*
* @author Yuri Shmakov
*/
public class Utils {
public static <T> Observable.Transformer<T, T> applySchedulers() {
return observable -> observable.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/common/Utils.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 101 |
```java
package com.arellomobile.mvp.sample.github.di;
import android.content.Context;
import com.arellomobile.mvp.sample.github.di.modules.BusModule;
import com.arellomobile.mvp.sample.github.di.modules.ContextModule;
import com.arellomobile.mvp.sample.github.di.modules.GithubModule;
import com.arellomobile.mvp.sample.github.mvp.GithubService;
import com.arellomobile.mvp.sample.github.mvp.presenters.RepositoriesPresenter;
import com.arellomobile.mvp.sample.github.mvp.presenters.RepositoryLikesPresenter;
import com.arellomobile.mvp.sample.github.mvp.presenters.SignInPresenter;
import com.squareup.otto.Bus;
import javax.inject.Singleton;
import dagger.Component;
/**
* Date: 8/18/2016
* Time: 14:49
*
* @author Artur Artikov
*/
@Singleton
@Component(modules = {ContextModule.class, BusModule.class, GithubModule.class})
public interface AppComponent {
Context getContext();
GithubService getAuthService();
Bus getBus();
void inject(SignInPresenter presenter);
void inject(RepositoriesPresenter repositoriesPresenter);
void inject(RepositoryLikesPresenter repositoryLikesPresenter);
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/di/AppComponent.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 233 |
```java
package com.arellomobile.mvp.sample.github.ui.fragments;
import java.util.List;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageButton;
import com.arellomobile.mvp.MvpAppCompatFragment;
import com.arellomobile.mvp.presenter.InjectPresenter;
import com.arellomobile.mvp.presenter.PresenterType;
import com.arellomobile.mvp.presenter.ProvidePresenter;
import com.arellomobile.mvp.sample.github.R;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.sample.github.mvp.presenters.RepositoryLikesPresenter;
import com.arellomobile.mvp.sample.github.mvp.presenters.RepositoryPresenter;
import com.arellomobile.mvp.sample.github.mvp.views.RepositoryLikesView;
import com.arellomobile.mvp.sample.github.mvp.views.RepositoryView;
import com.arellomobile.mvp.sample.github.ui.views.RepositoryWidget;
import butterknife.BindView;
import butterknife.ButterKnife;
/**
* Date: 27.01.2016
* Time: 20:17
*
* @author Yuri Shmakov
*/
public class DetailsFragment extends MvpAppCompatFragment implements RepositoryView, RepositoryLikesView {
public static final String ARGS_REPOSITORY = "argsRepository";
@InjectPresenter
RepositoryPresenter mRepositoryPresenter;
@InjectPresenter(type = PresenterType.WEAK, tag = RepositoryLikesPresenter.TAG)
RepositoryLikesPresenter mRepositoryLikesPresenter;
private Repository mRepository;
@BindView(R.id.fragment_repository_details_text_view_title)
RepositoryWidget mTitleTextView;
@BindView(R.id.fragment_repository_details_image_button_like)
ImageButton mLikeImageButton;
@ProvidePresenter
RepositoryPresenter provideRepositoryPresenter() {
mRepository = (Repository) getArguments().get(ARGS_REPOSITORY);
return new RepositoryPresenter(mRepository);
}
public static DetailsFragment getInstance(Repository repository) {
DetailsFragment fragment = new DetailsFragment();
Bundle args = new Bundle();
args.putSerializable(ARGS_REPOSITORY, repository);
fragment.setArguments(args);
return fragment;
}
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
return inflater.inflate(R.layout.fragment_repository_details, container, false);
}
@Override
public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
ButterKnife.bind(this, view);
mLikeImageButton.setOnClickListener(likeImageButton -> mRepositoryLikesPresenter.toggleLike(mRepository.getId()));
}
@Override
public void updateLikes(List<Integer> inProgress, List<Integer> likedIds) {
mRepositoryPresenter.updateLikes(inProgress, likedIds);
}
@Override
public void showRepository(Repository repository) {
mRepository = repository;
mTitleTextView.initWidget(getMvpDelegate(), repository);
}
@Override
public void updateLike(boolean isInProgress, boolean isLiked) {
mLikeImageButton.setEnabled(!isInProgress);
mLikeImageButton.setSelected(isLiked);
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/ui/fragments/DetailsFragment.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 627 |
```java
package com.arellomobile.mvp.sample.github.di.modules;
import com.arellomobile.mvp.sample.github.app.GithubApi;
import com.squareup.otto.Bus;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
/**
* Date: 20.09.2016
* Time: 20:22
*
* @author Yuri Shmakov
*/
@Module
public class BusModule {
@Provides
@Singleton
public Bus provideBus(GithubApi authApi) {
return new Bus();
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/di/modules/BusModule.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 112 |
```java
package com.arellomobile.mvp.sample.github.di.modules;
import com.arellomobile.mvp.sample.github.app.GithubApi;
import com.arellomobile.mvp.sample.github.mvp.GithubService;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
/**
* Date: 8/26/2016
* Time: 11:58
*
* @author Artur Artikov
*/
@Module(includes = {ApiModule.class})
public class GithubModule {
@Provides
@Singleton
public GithubService provideGithubService(GithubApi authApi) {
return new GithubService(authApi);
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/di/modules/GithubModule.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 132 |
```java
package com.arellomobile.mvp.sample.github.di.modules;
import java.lang.reflect.Field;
import com.google.gson.FieldNamingPolicy;
import com.google.gson.FieldNamingStrategy;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
import retrofit2.Converter;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;
import rx.schedulers.Schedulers;
/**
* Date: 8/26/2016
* Time: 12:28
*
* @author Artur Artikov
*/
@Module
public class RetrofitModule {
@Provides
@Singleton
public Retrofit provideRetrofit(Retrofit.Builder builder) {
return builder.baseUrl("path_to_url").build();
}
@Provides
@Singleton
public Retrofit.Builder provideRetrofitBuilder(Converter.Factory converterFactory) {
return new Retrofit.Builder()
.addCallAdapterFactory(RxJavaCallAdapterFactory.createWithScheduler(Schedulers.io()))
.addConverterFactory(converterFactory);
}
@Provides
@Singleton
public Converter.Factory provideConverterFactory(Gson gson) {
return GsonConverterFactory.create(gson);
}
@Provides
@Singleton
Gson provideGson() {
return new GsonBuilder()
.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)
.setFieldNamingStrategy(new CustomFieldNamingPolicy())
.setPrettyPrinting()
.setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
.serializeNulls()
.create();
}
private static class CustomFieldNamingPolicy implements FieldNamingStrategy {
@Override
public String translateName(Field field) {
String name = FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES.translateName(field);
name = name.substring(2, name.length()).toLowerCase();
return name;
}
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/di/modules/RetrofitModule.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 399 |
```java
package com.arellomobile.mvp.sample.github.di.modules;
import com.arellomobile.mvp.sample.github.app.GithubApi;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
import retrofit2.Retrofit;
/**
* Date: 9/2/2016
* Time: 18:54
*
* @author Artur Artikov
*/
@Module(includes = {RetrofitModule.class})
public class ApiModule {
@Provides
@Singleton
public GithubApi provideAuthApi(Retrofit retrofit) {
return retrofit.create(GithubApi.class);
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/di/modules/ApiModule.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 123 |
```java
package com.arellomobile.mvp.sample.github.di.modules;
import android.content.Context;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
/**
* Date: 8/18/2016
* Time: 14:50
*
* @author Artur Artikov
*/
@Module
public class ContextModule {
private Context mContext;
public ContextModule(Context context) {
mContext = context;
}
@Provides
@Singleton
public Context provideContext() {
return mContext;
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/di/modules/ContextModule.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 110 |
```java
package com.arellomobile.mvp.sample.github.app;
import java.util.List;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.sample.github.mvp.models.User;
import com.arellomobile.mvp.sample.github.mvp.models.gson.SearchResult;
import retrofit2.Call;
import retrofit2.Response;
import retrofit2.http.GET;
import retrofit2.http.Header;
import retrofit2.http.Path;
import retrofit2.http.Query;
import rx.Observable;
/**
* Date: 18.01.2016
* Time: 12:07
*
* @author Yuri Shmakov
*/
public interface GithubApi {
Integer PAGE_SIZE = 50;
@GET("/user")
Observable<User> signIn(@Header("Authorization") String token);
@GET("/search/repositories?sort=stars&order=desc")
Observable<SearchResult> search(@Query("q") String query);
@GET("/users/{login}/repos")
Observable<List<Repository>> getUserRepos(@Path("login") String login, @Query("page") int page, @Query("per_page") int pageSize);
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/app/GithubApi.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 233 |
```java
package com.arellomobile.mvp.sample.github.app;
import android.app.Application;
import android.support.annotation.NonNull;
import android.support.annotation.VisibleForTesting;
import com.arellomobile.mvp.sample.github.di.AppComponent;
import com.arellomobile.mvp.sample.github.di.DaggerAppComponent;
import com.arellomobile.mvp.sample.github.di.modules.ContextModule;
/**
* Date: 18.01.2016
* Time: 11:22
*
* @author Yuri Shmakov
*/
public class GithubApp extends Application {
private static AppComponent sAppComponent;
@Override
public void onCreate() {
super.onCreate();
sAppComponent = DaggerAppComponent.builder()
.contextModule(new ContextModule(this))
.build();
}
public static AppComponent getAppComponent() {
return sAppComponent;
}
@VisibleForTesting
public static void setAppComponent(@NonNull AppComponent appComponent) {
sAppComponent = appComponent;
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/app/GithubApp.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 192 |
```java
package com.arellomobile.mvp.sample.github.app;
import java.io.IOException;
import org.json.JSONException;
import org.json.JSONObject;
import okhttp3.ResponseBody;
/**
* Date: 18.01.2016
* Time: 14:11
*
* @author Yuri Shmakov
*/
public class GithubError extends Throwable {
public GithubError(ResponseBody responseBody) {
super(getMessage(responseBody));
}
private static String getMessage(ResponseBody responseBody) {
try {
return new JSONObject(responseBody.string()).optString("message");
} catch (JSONException | IOException e) {
e.printStackTrace();
}
return "Unknown exception";
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/app/GithubError.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 138 |
```java
package com.arellomobile.mvp.sample.github.mvp;
import java.util.List;
import com.arellomobile.mvp.sample.github.app.GithubApi;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.sample.github.mvp.models.User;
import rx.Observable;
/**
* Date: 20.09.2016
* Time: 20:14
*
* @author Yuri Shmakov
*/
public class GithubService {
private GithubApi mGithubApi;
public GithubService(GithubApi githubApi) {
mGithubApi = githubApi;
}
public Observable<User> signIn(String token) {
return mGithubApi.signIn(token);
}
public Observable<List<Repository>> getUserRepos(String user, int page, Integer pageSize) {
return mGithubApi.getUserRepos(user, page, pageSize);
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/GithubService.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 178 |
```java
package com.arellomobile.mvp.sample.github.mvp.common;
/**
* Date: 18.01.2016
* Time: 15:02
*
* @author Yuri Shmakov
*/
public class AuthUtils {
private static final String TOKEN = "token";
public static String getToken() {
return PrefUtils.getPrefs().getString(TOKEN, "");
}
public static void setToken(String token) {
PrefUtils.getEditor().putString(TOKEN, token).commit();
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/common/AuthUtils.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 105 |
```java
package com.arellomobile.mvp.sample.github.mvp.common;
import android.content.Context;
import android.content.SharedPreferences;
import com.arellomobile.mvp.sample.github.app.GithubApp;
/**
* Date: 18.01.2016
* Time: 15:01
*
* @author Yuri Shmakov
*/
public class PrefUtils {
private static final String PREF_NAME = "github";
public static SharedPreferences getPrefs() {
return GithubApp.getAppComponent().getContext().getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
}
public static SharedPreferences.Editor getEditor() {
return getPrefs().edit();
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/common/PrefUtils.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 128 |
```java
package com.arellomobile.mvp.sample.github.mvp.views;
import java.util.List;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.strategy.AddToEndSingleStrategy;
import com.arellomobile.mvp.viewstate.strategy.AddToEndStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 22.01.2016
* Time: 14:40
*
* @author Yuri Shmakov
*/
@StateStrategyType(AddToEndSingleStrategy.class)
public interface RepositoriesView extends MvpView {
void showError(String message);
void hideError();
void onStartLoading();
void onFinishLoading();
void showRefreshing();
void hideRefreshing();
void showListProgress();
void hideListProgress();
void setRepositories(List<Repository> repositories, boolean maybeMore);
@StateStrategyType(AddToEndStrategy.class)
void addRepositories(List<Repository> repositories, boolean maybeMore);
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/views/RepositoriesView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 209 |
```java
package com.arellomobile.mvp.sample.github.mvp.views;
import java.util.List;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.strategy.AddToEndSingleStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 26.01.2016
* Time: 16:33
*
* @author Yuri Shmakov
*/
public interface RepositoryLikesView extends MvpView {
@StateStrategyType(AddToEndSingleStrategy.class)
void updateLikes(List<Integer> inProgress, List<Integer> likedIds);
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/views/RepositoryLikesView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 126 |
```java
package com.arellomobile.mvp.sample.github.mvp.views;
import com.arellomobile.mvp.MvpView;
/**
* Date: 18.01.2016
* Time: 16:04
*
* @author Yuri Shmakov
*/
public interface SignOutView extends MvpView {
void signOut();
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/views/SignOutView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 69 |
```java
package com.arellomobile.mvp.sample.github.mvp.views;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.MvpView;
/**
* Date: 27.01.2016
* Time: 21:13
*
* @author Yuri Shmakov
*/
public interface RepositoryView extends MvpView {
void showRepository(Repository repository);
void updateLike(boolean isInProgress, boolean isLiked);
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/views/RepositoryView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 95 |
```java
package com.arellomobile.mvp.sample.github.mvp.views;
import com.arellomobile.mvp.MvpView;
/**
* Date: 18.01.2016
* Time: 15:39
*
* @author Yuri Shmakov
*/
public interface SplashView extends MvpView {
void setAuthorized(boolean isAuthorized);
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/views/SplashView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 71 |
```java
package com.arellomobile.mvp.sample.github.mvp.views;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.viewstate.strategy.AddToEndSingleStrategy;
import com.arellomobile.mvp.viewstate.strategy.OneExecutionStateStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 27.01.2016
* Time: 20:00
*
* @author Yuri Shmakov
*/
@StateStrategyType(AddToEndSingleStrategy.class)
public interface HomeView extends MvpView {
void showDetailsContainer();
void setSelection(int position);
@StateStrategyType(OneExecutionStateStrategy.class)
void showDetails(int position, Repository repository);
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/views/HomeView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 164 |
```java
package com.arellomobile.mvp.sample.github.mvp.views;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.strategy.SingleStateStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Created by senneco on 23.10.2016
*/
public interface RepositoryLikeView extends MvpView {
@StateStrategyType(SingleStateStrategy.class)
void setState(boolean isInProgress, boolean isLiked);
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/views/RepositoryLikeView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 101 |
```java
package com.arellomobile.mvp.sample.github.mvp.models;
import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.table.DatabaseTable;
/**
* Date: 18.01.2016
* Time: 12:09
*
* @author Yuri Shmakov
*/
@DatabaseTable
public class User {
public static class Column {
public static final String ID = "_id";
public static final String LOGIN = "login";
public static final String AVATAR = "avatar";
public static final String PUBLIC_REPOS = "public_repos";
public static final String PUBLIC_GISTS = "public_gists";
public static final String FOLLOWERS = "followers";
public static final String FOLLOWING = "following";
}
@DatabaseField(columnName = Column.ID, id = true)
private int mId;
@DatabaseField(columnName = Column.LOGIN)
private String mLogin;
@DatabaseField(columnName = Column.AVATAR)
private String mAvatarUrl;
@DatabaseField(columnName = Column.PUBLIC_REPOS)
private int mPublicRepos;
@DatabaseField(columnName = Column.PUBLIC_GISTS)
private int mPublicGists;
@DatabaseField(columnName = Column.FOLLOWERS)
private int mFollower;
@DatabaseField(columnName = Column.FOLLOWING)
private int mFollowing;
public int getId() {
return mId;
}
public void setId(int id) {
mId = id;
}
public String getLogin() {
return mLogin;
}
public void setLogin(String login) {
mLogin = login;
}
public String getName() {
return mLogin;
}
public void setName(String login) {
mLogin = login;
}
public String getAvatarUrl() {
return mAvatarUrl;
}
public void setAvatarUrl(String avatarUrl) {
mAvatarUrl = avatarUrl;
}
public int getPublicRepos() {
return mPublicRepos;
}
public void setPublicRepos(int publicRepos) {
mPublicRepos = publicRepos;
}
public int getPublicGists() {
return mPublicGists;
}
public void setPublicGists(int publicGists) {
mPublicGists = publicGists;
}
public int getFollower() {
return mFollower;
}
public void setFollower(int follower) {
mFollower = follower;
}
public int getFollowing() {
return mFollowing;
}
public void setFollowing(int following) {
mFollowing = following;
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/models/User.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 549 |
```java
package com.arellomobile.mvp.sample.github.mvp.views;
import com.arellomobile.mvp.MvpView;
import com.arellomobile.mvp.viewstate.strategy.AddToEndSingleStrategy;
import com.arellomobile.mvp.viewstate.strategy.SkipStrategy;
import com.arellomobile.mvp.viewstate.strategy.StateStrategyType;
/**
* Date: 15.01.2016
* Time: 18:41
*
* @author Yuri Shmakov
*/
@StateStrategyType(AddToEndSingleStrategy.class)
public interface SignInView extends MvpView {
void startSignIn();
void finishSignIn();
void failedSignIn(String message);
void hideError();
void hideFormError();
void showFormError(Integer emailError, Integer passwordError);
@StateStrategyType(SkipStrategy.class)
void successSignIn();
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/views/SignInView.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 166 |
```java
package com.arellomobile.mvp.sample.github.mvp.models.gson;
import java.util.List;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
/**
* Date: 18.01.2016
* Time: 12:13
*
* @author Yuri Shmakov
*/
public class SearchResult {
private int mTotalCount;
private boolean mIncompleteResults;
private List<Repository> mItems;
public List<Repository> getRepositories() {
return mItems;
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/models/gson/SearchResult.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 103 |
```java
package com.arellomobile.mvp.sample.github.mvp.presenters;
import java.util.List;
import com.arellomobile.mvp.InjectViewState;
import com.arellomobile.mvp.MvpPresenter;
import com.arellomobile.mvp.sample.github.mvp.models.Repository;
import com.arellomobile.mvp.sample.github.mvp.views.RepositoryView;
/**
* Date: 27.01.2016
* Time: 21:12
*
* @author Yuri Shmakov
*/
@InjectViewState
public class RepositoryPresenter extends MvpPresenter<RepositoryView> {
private Repository mRepository;
private List<Integer> mInProgress;
private List<Integer> mLikedIds;
public RepositoryPresenter(Repository repository) {
super();
mRepository = repository;
}
@Override
protected void onFirstViewAttach() {
super.onFirstViewAttach();
getViewState().showRepository(mRepository);
updateLikes(mInProgress, mLikedIds);
}
public void updateLikes(List<Integer> inProgress, List<Integer> likedIds) {
mInProgress = inProgress;
mLikedIds = likedIds;
if (mRepository == null || mInProgress == null || mLikedIds == null) {
return;
}
boolean isInProgress = inProgress.contains(mRepository.getId());
boolean isLiked = likedIds.contains(mRepository.getId());
getViewState().updateLike(isInProgress, isLiked);
}
}
``` | /content/code_sandbox/sample-github/src/main/java/com/arellomobile/mvp/sample/github/mvp/presenters/RepositoryPresenter.java | java | 2016-02-12T08:35:25 | 2024-07-28T20:03:03 | Moxy | Arello-Mobile/Moxy | 1,609 | 288 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.