android - Square Flow + モルタルタブレットの例

Question

Android アプリの代替アーキテクチャとしてフローとモルタルを使用して実験してきました。私は今のところ単一の電話レイアウトだけのアプリに取り組んでいますが、タブレット用に別のレイアウトが必要な場合、フローとモルタルアーキテクチャがどのように機能するのか疑問に思っていました. マスター詳細は最も単純な例かもしれませんが、明らかに他の例があります。

これがどのように機能するかについていくつかのアイデアがありますが、このトピックに関して、スクエアの開発者がすでに考えていることを知りたいと思いました.

score 16 · Accepted Answer

これに対する標準的な回答についてはまだ取り組んでいますが、基本的な考え方は、どの状況でどのビューを表示するかをリソースシステムに変更させるというものです。したがって、アクティビティはそのコンテンツビューを、たとえばに設定しますR.layout.root_view。そのレイアウトのタブレットバージョン ( に配置res/layout-sw600dp) は、さまざまなビューに関連付けることができ、さまざまなプレゼンターが挿入される可能性があります。

ランタイムの決定を行う必要がある場合は、ブール値のリソースを定義します。values/bools .xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <bool name="show_tablet_ui">false</bool>
</resources>

とvalues-sw600dp/bools.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <bool name="show_tablet_ui">true</bool>
</resources>

短剣を介してアプリの残りの部分に公開します。次のバインディングアノテーションを使用します。

/**
 * Whether we should show a tablet UI.
 */
@Retention(RUNTIME) @Qualifier
public @interface ShowTabletUi {
  int ID = R.bool.show_tablet_ui;
}

そして、次のようなプロバイダーメソッド:

/** 
 * Singleton because there's no reason to read it from resources again, 
 * it won't change. 
 */
@Provides @ShowTabletUi @Singleton boolean showTabletUi(Resources resources) {
  return resources.getBoolean(ShowTabletUi.ID);
}

しかし、もっと待ってください！さまざまなフォームファクター用にさまざまなモジュールを製造する単一の画面 / ブループリント定義が必要だとします。そのようなことを単純化するために、注釈スキームの使用を開始しました。画面クラスをすべて実装する代わりに、BluePrintいくつかの注釈を使用してそれらのインターフェイスクラスを宣言し始めました。その世界では、画面がタブレットまたはモバイルに使用するモジュールを選択する方法を次に示します。

@Layout(R.layout.some_view) @WithModuleFactory(SomeScreen.ModuleFactory.class)
public class SomeScreen {
  public static class ModuleFactory extends ResponsiveModuleFactory<HomeScreen> {
  @Override protected Object createTabletModule(HomeScreen screen) {
    return new TabletModule();
  }

  @Override protected Object createMobileModule(HomeScreen screen) {
    return new MobileModule();
  }
}

魔法ですよね？カーテンの後ろにあるものは次のとおりです。まず、 aModuleFactoryは、画面とリソースへのアクセスが与えられ、短剣モジュールを吐き出す静的クラスです。

public abstract class ModuleFactory<T> {
  final Blueprint createBlueprint(final Resources resources, final MortarScreen screen) {
    return new Blueprint() {
      @Override public String getMortarScopeName() {
        return screen.getName();
      }

      @Override public Object getDaggerModule() {
        return ModuleFactory.this.createDaggerModule(resources, (T) screen);
      }
    };
  }

  protected abstract Object createDaggerModule(Resources resources, T screen);
}

trixieResponsiveModuleFactoryサブクラスは次のようになります。ShowTabletUi.java(リソース ID を定数として定義したことを覚えていますか? これが理由です。)

public abstract class ResponsiveModuleFactory<T> extends ModuleFactory<T> {

  @Override protected final Object createDaggerModule(Resources resources, T screen) {
    boolean showTabletUi = resources.getBoolean(ShowTabletUi.ID);
    return showTabletUi ? createTabletModule(screen) : createMobileModule(screen);
  }

  protected abstract Object createTabletModule(T screen);

  protected abstract Object createMobileModule(T screen);
}

これらすべてを実現するために、ScreenScoper クラス (以下) があります。Mortar サンプルコードでは、ScreenConductor でこれらのいずれかを使用してスコープを作成および破棄します。遅かれ早かれ (近いうちに) Mortar および/またはそのサンプルが更新され、この内容が含まれるようになります。

package mortar;

import android.content.Context;
import android.content.res.Resources;
import com.squareup.util.Objects;
import dagger.Module;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.LinkedHashMap;
import java.util.Map;

import static java.lang.String.format;

/**
 * Creates {@link MortarScope}s for screens that may be annotated with {@link WithModuleFactory},
 * {@link WithModule} or {@link Module}.
 */
public class ScreenScoper {
  private static final ModuleFactory NO_FACTORY = new ModuleFactory() {
    @Override protected Object createDaggerModule(Resources resources, Object screen) {
      throw new UnsupportedOperationException();
    }
  };

  private final Map<Class, ModuleFactory> moduleFactoryCache = new LinkedHashMap<>();

  public MortarScope getScreenScope(Context context, final MortarScreen screen) {
    MortarScope parentScope = Mortar.getScope(context);
    return getScreenScope(context.getResources(), parentScope, screen);
  }

  /**
   * Finds or creates the scope for the given screen, honoring its optoinal {@link
   * WithModuleFactory} or {@link WithModule} annotation. Note the scopes are also created
   * for unannotated screens.
   */
  public MortarScope getScreenScope(Resources resources, MortarScope parentScope,
      final MortarScreen screen) {
    ModuleFactory moduleFactory = getModuleFactory(screen);
    MortarScope childScope;
    if (moduleFactory != NO_FACTORY) {
      Blueprint blueprint = moduleFactory.createBlueprint(resources, screen);
      childScope = parentScope.requireChild(blueprint);
    } else {
      // We need every screen to have a scope, so that anything it injects is scoped.  We need
      // this even if the screen doesn't declare a module, because Dagger allows injection of
      // objects that are annotated even if they don't appear in a module.
      Blueprint blueprint = new Blueprint() {
        @Override public String getMortarScopeName() {
          return screen.getName();
        }

        @Override public Object getDaggerModule() {
          return null;
        }
      };
      childScope = parentScope.requireChild(blueprint);
    }
    return childScope;
  }

  private ModuleFactory getModuleFactory(MortarScreen screen) {
    Class<?> screenType = Objects.getClass(screen);
    ModuleFactory moduleFactory = moduleFactoryCache.get(screenType);

    if (moduleFactory != null) return moduleFactory;

    WithModule withModule = screenType.getAnnotation(WithModule.class);
    if (withModule != null) {
      Class<?> moduleClass = withModule.value();

      Constructor<?>[] constructors = moduleClass.getDeclaredConstructors();

      if (constructors.length != 1) {
        throw new IllegalArgumentException(
            format("Module %s for screen %s should have exactly one public constructor",
                moduleClass.getName(), screen.getName()));
      }

      Constructor constructor = constructors[0];

      Class[] parameters = constructor.getParameterTypes();

      if (parameters.length > 1) {
        throw new IllegalArgumentException(
            format("Module %s for screen %s should have 0 or 1 parameter", moduleClass.getName(),
                screen.getName()));
      }

      Class screenParameter;
      if (parameters.length == 1) {
        screenParameter = parameters[0];
        if (!screenParameter.isInstance(screen)) {
          throw new IllegalArgumentException(format("Module %s for screen %s should have a "
                  + "constructor parameter that is a super class of %s", moduleClass.getName(),
              screen.getName(), screen.getClass().getName()));
        }
      } else {
        screenParameter = null;
      }

      try {
        if (screenParameter == null) {
          moduleFactory = new NoArgsFactory(constructor);
        } else {
          moduleFactory = new SingleArgFactory(constructor);
        }
      } catch (Exception e) {
        throw new RuntimeException(
            format("Failed to instantiate module %s for screen %s", moduleClass.getName(),
                screen.getName()), e);
      }
    }

    if (moduleFactory == null) {
      WithModuleFactory withModuleFactory = screenType.getAnnotation(WithModuleFactory.class);
      if (withModuleFactory != null) {
        Class<? extends ModuleFactory> mfClass = withModuleFactory.value();

        try {
          moduleFactory = mfClass.newInstance();
        } catch (Exception e) {
          throw new RuntimeException(format("Failed to instantiate module factory %s for screen %s",
              withModuleFactory.value().getName(), screen.getName()), e);
        }
      }
    }

    if (moduleFactory == null) moduleFactory = NO_FACTORY;

    moduleFactoryCache.put(screenType, moduleFactory);

    return moduleFactory;
  }

  private static class NoArgsFactory extends ModuleFactory<Object> {
    final Constructor moduleConstructor;

    private NoArgsFactory(Constructor moduleConstructor) {
      this.moduleConstructor = moduleConstructor;
    }

    @Override protected Object createDaggerModule(Resources resources, Object ignored) {
      try {
        return moduleConstructor.newInstance();
      } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
        throw new RuntimeException(e);
      }
    }
  }

  private static class SingleArgFactory extends ModuleFactory {
    final Constructor moduleConstructor;

    public SingleArgFactory(Constructor moduleConstructor) {
      this.moduleConstructor = moduleConstructor;
    }

    @Override protected Object createDaggerModule(Resources resources, Object screen) {
      try {
        return moduleConstructor.newInstance(screen);
      } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
        throw new RuntimeException(e);
      }
    }
  }
}

android - Square Flow + モルタル タブレットの例

1 に答える 1

Related

Reference

android - Square Flow + モルタルタブレットの例