Android/App개발2020. 4. 6. 14:45

https://medium.com/google-exoplayer/playback-notifications-with-exoplayer-a2f1a18cf93b

 

PlayerNotificationManager를 통해 미디어재생 시 알림센터에 정보를 표시하고 제어할 수 있다.

1. PlayerNotificationManager인스턴스 생성
2. PlayerNotificationManager.MediaDescriptionAdapter 로 재생중인 미디어 아이템 정보를 제공
3. 플레이어에 연결, 리소스가 소거되었을 때는 연결해제

PlayerNotificationManager 인스턴스 생성
 activity나 fragment의 onCreate에서 생성한다. 

@Override
public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  ...
  playerNotificationManager = new PlayerNotificationManager(
      this,
      new DescriptionAdapter(), 
      CHANNEL_ID,
      NOTIFICATION_ID);
}

채널아이디, 알림아이디, 그리고 재생중인 미디어 정보를 제공하기 위해 MediaDescriptionAdapter를 확장한 DescriptionAdapter를 파라메터로 넘긴다.

private class DescriptionAdapter implements
    PlayerNotificationManager.MediaDescriptionAdapter {
    
  @Override
  public String getCurrentContentTitle(Player player) {
    int window = player.getCurrentWindowIndex();
    return getTitle(window);
  }

  @Nullable
  @Override
  public String getCurrentContentText(Player player) {
    int window = player.getCurrentWindowIndex();
    return getDescription(window);
  }

  @Nullable
  @Override
  public Bitmap getCurrentLargeIcon(Player player,
      PlayerNotificationManager.BitmapCallback callback) {
    int window = player.getCurrentWindowIndex();
    Bitmap largeIcon = getLargeIcon(window);
    if (largeIcon == null && getLargeIconUri(window) != null) {
      // load bitmap async
      loadBitmap(getLargeIconUri(window), callback); 
      return getPlaceholderBitmap();
    }
    return largeIcon;
  }

  @Nullable
  @Override
  public PendingIntent createCurrentContentIntent(Player player) {
    int window = player.getCurrentWindowIndex();
    return createPendingIntent(window);
  }
}

플레이어에 연결은 다음과 같이 한다.

player = ExoPlayerFactory.newSimpleInstance(renderersFactory, trackSelector);
playerNotificationManager.setPlayer(player);

플레이어가 해제되기 전에 먼저 연결을 끊어야 한다.

playerNotificationManager.setPlayer(null);
player.release();
player = null;


커스텀하기

 앱의 테마에 맞도록 알림을 커스텀하는 다양한 방법이 존재한다. 재생컨트롤의 동작여부를 설정하고 알림속성을 설정할 수 있도록 매니져가 기능을 제공한다. 이 속성들은 기본값을 가지고 있고 쉽게 바꿀수 있다.

재생컨트롤 액션들

 기본 컨트롤액션을 제공한다. 재생/일시정지, FF/REW, Next/Previous, Stop등이 있으며 생략도 가능하다

// omit skip previous and next actions
playerNotificationManager.setUseNavigationActions(false);
// omit fast forward action by setting the increment to zero
playerNotificationManager.setFastForwardIncrementMs(0);
// omit rewind action by setting the increment to zero
playerNotificationManager.setRewindIncrementMs(0);
// omit the stop action
playerNotificationManager.setStopAction(null);

커스텀액션도 CustionActionReceiver를 확장하여 구현하여 PlayerNotificationManager 생성자의 5번째 파라메터로 넣어서 구현 가능하다.

알림 속성

 알림매니저는 UI와 알림의 동작의 setter를 제공한다. 이는 NotificationCompat.Builder의 속성에 상응한다.

manager.setOngoing(false);
manager.setColor(Color.BLACK);
manager.setColorized(true);
manager.setUseChronometer(false);
manager.setSmallIcon(R.drawable.exo_notification_small_icon);
manager.setBadgeIconType(NotificationCompat.BADGE_ICON_NONE);
manager.setVisibility(NotificationCompat.VISIBILITY_PRIVATE);

MediaSession

 최종적으로 Google Assistant등을 지원하기 위해 MediaSession API를 사용하고 있다면 media style 알림의 장점을 모두 취하기 위해 session에 token을 셋팅할수 있다.

 playerNotificationManager.setMediaSessionToken(token);




 

Playback Notifications with ExoPlayer

Displaying a notification with playback controls is a best practice for media apps on Android. For audio playback in the background it’s…

medium.com

 

Posted by 삼스

댓글을 달아 주세요

Android/App개발2020. 2. 12. 14:45

https://medium.com/@elye.project/mastering-kotlin-standard-functions-run-with-let-also-and-apply-9cd334b0ef84

 

코틀린 표준 함수들 일부는 어디에 사용하는지 명확하게 알지 못한다. 이에 대해 그 차이점을 명확하게 설명하고 어떤걸 사용해야 하는지 소개하고자 한다.

범위함수(Scoping functions)

run, with, T.run, T.let, T.also 그리고 T.apply에 대해 집중할거다. 

다음은 run함수의 범위지정기능을 설명하는 간단한 코드이다.

불러오는 중입니다...

 

fun test() {
  var mood = "I am sad"

  run {
    val mood = "I am happy"
    println(mood)   // I am happy
  }

  println(mood) // I am sad
}



test함수 내의 분리된 범위에서 mood는 재정의 되고 "I am happy"가 프린트된다. run 범위내에 제한된다.
이게 범위지정함수인데 별로 유용해보이지 않지만 범위지정으로써의 장점이 있다. 먼가를 반환할 수 있다.

아래코드를 보면 show()를 두번 호출하지 않고 두개의 view에 적용이 가능하다.

run {
  if (firstTimeVIew) introView
  else normalView
}.show()



범위지정함수의 3가지 속성

범위지정함수를 좀더 흥미있게 만들기 위해 3가지 속성으로 나누고 이를 통해 각각을 구별할 수 있다.

1. Normal vs. extension function

with, T.run 은 상당히 유사하다.

with(webview.settings) {
  javascriptEnabled = true
  databaseEnabled = true
}

webview.settings.run {
  javascriptEnabled = true
  databaseEnabled = true 
}



두가지 차이점은 일반함수냐 확장함수냐이다. 그래서 각각의 장점은 멀까?

webview.settings가 null일 수 있다고 생각해보자

// 별로다
with(webview.settings) {
  this?.javascriptEnabled = true
  this?.databaseEnabled = true
}

// 이게 더 좋아
webview.settings?.run {
  javascriptEnabled = true
  databaseEnabled = true
}


이 경우는 T.run 사용이 더 유용하다.


2. This vs. it 인자

strVal?.run {
  println("The length of this String is $length")
}

strVal?.let {
  println("The length of this String is $it.length")
}


T.run의 경우 block: T.()의 형태를 가지며 따라서 범위내에서 this로 참조가 가능하다. this의 경우 일반적으로 생략이 가능하므로 $this.length가 아니라 $length가 가능하다.

T.let의 경우 block: (T)의 형태를 가지며 인자를 따로 명시하지 않으면 it으로 접근이 가능하다.


위 예를 보면 T.run이 좀더 암시적이어서 우세해 보이나 T.let의 장점도 존재한다.

* let은 함수/멤버 변수를 외부 클래스 함수/멤버와 구별하기가 더 좋다.
* 파라메터로 this가 전달되면 생략이 불가한데 it이 더 짧고 명확하다
* let은 변수명을 it이 아니라 다른 이름으로 부여가 가능하다.

value?.let { myname -> 
  println("The name is $myname");
}


3. this 또는 다른 타입의 반환

value?.let {
  println("The length of val is ${it.length}")
}

value?.also {
  println("The length of val is ${it.length}")
}


두가지의 차이점은 let은 임의 타입을 반환하고 also는 동일한 this타입을 반환한다.
둘다 체이닝함수에 유용한다. T.let은 연산된 결과를 다음 체인에 전달하고 T.also는 동일한 객체를 전달한다.

val original = "abc"

original.let {
  prinln("The original string is $it") // 원래 문자열
  it.reversed() // 리버스된 문자열 반환
}.let {
  println("Ths reversed string is $it") 
  it.length. // 문자열길이 반환
}.let {
  println("The length is $it") // 전달받은 타입은 숫자
}

original.let {
  prinln("The original string is $it")
  it.reversed()
}.also {
  println("Ths reversed string is $it") // "abc" 프린트
  it.length
}.also {  
  println("The length is $it")  // "abc" 프린트
}

original.also {
  prinln("The original string is $it")
}.also {
  println("Ths reversed string is ${it.reversed()}") // 리버스된 문자열 프린트
}.also {  
  println("The length is ${it.length}")  // 문자열 길이 프린트
}


위 샘플을 보면 also가 더이상 무슨 소용이 있나 싶을 수 있지만 잘생각해 보면 좋은 장점이 있다.

1. 동일 객체에 대한 일련의 처리를 명확하게 구분할 수 있게 해준다.
2. 체이닝 빌드 연산을 만듦으로 객체를 스스로 조작하는데 파워풀한 기능을 제공한다.

두가지를 합쳐서 한번은 변환하고 이어서 그 객체를 조작하는 체이닝을 만들 수 있다.

// 일반적인 접근
fun makeDir(path: String): File {
  val result = File(path)
  result.mkdirs()
  return result
}

// 향상된 접근
fun makeDir(path: String) = path.let{ File(it) }.also{ it.mkdirs() }


모든 속성 살펴보기

T.apply로 3가지 속성을 살펴보는것으로 더 많은것을 알 수 있다.

1. 함수의 확장이 필요한가?
2. 인자로서 this를 전달이 필요한가?
3. this를 반환이 필요한가?

// 일반적인 접근
fun createInstance(args: Bundle) : MyFragment {
  val fragment = MyFragment()
  fragment.arguments = args
  return fragment
}

// 향상된 접근
fun createInstance(args: Bundle) = MyFragment().apply { argument = args }
fun createInstance(args: Bundle) = MyFragment().also { it.argument = args }



this를 반환하기 때문에 체이닝이 가능하다.

// 일반적인 접근
fun createIntent(intentData: String, intentAction: String) : MyFragment {
  val intent = Intent()
  intent.action = intentAction
  intent.data = Uri.parse(intentData)
  return intent
}

fun createIntent(intentData: String, intentAction: String) = Intent()
    .apply { action = intentAction }
    .apply { data = intentData }

fun createIntent(intentData: String, intentAction: String) = Intent()
    .also { it.action = intentAction }
    .also { it.data = intentData }

위에서 설명한 표준함수들을 선택하는데 있어 선택장애자를 위한 표는 다음과 같다.

 




Posted by 삼스

댓글을 달아 주세요

Android2019. 11. 10. 16:57

https://medium.com/ionic-and-the-mobile-web/how-to-write-cordova-plugins-864e40025f2

 

How to write Cordova Plugins

Cordova Plugins are one of the dark arts of hybrid app development, helping web apps running natively access the full power of the device…

medium.com

두가지 방법이 있다. 첫번째는 plugman toole로 빠르게 만들수 있고 또는 기존 플러그인을 복제하여 수정하는 방법이다.

여기서는 복제하여 수정하는 방법을 설명한다.

 

Cordova Device plugin이 선택되었다.

 

 

plugin.xml에 중요한 정보들이 기술된다. src 폴더에는 네이티브 코드가 플랫폼별로 있고 www폴더는 javascript코드가 있다. 

 

이제 나만의 플러그인을 만들기 위해 위코드를 작업을 하기 위한 폴더로 모두 옮겨보자

 

먼저  plugin.xml을 열어서 플러그인아이디를 변경한다. 

여기서는 my-cordova-plugin으로 정했다.

 

javascript code의 위치도 기술한다.

js-module은 실행된 js code에 대해 기술하며 clobber는 window변수를 의미한다. 여기서는 www/plugin.js가 로드되면 이 때 부터 window.MyCordovaPlugin으로 플러그인에 접근가능해진다.

 

다음으로는 지원한 플랫폼에 대해 기술한다.

 

config파일에서 안드로이드 패키지명과 플러그인에서 사용한 코도바 심볼에 대해서 기술하게 되는데 이 경우 MyCordovaPlugin이며 자바코드와 연결된다.

 

iOS의 경우는 

안드로이드와 비슷하다. 플러그인은 swift로 개발이 가능하나 코도바가 objc이어서 인터페이스하는데 비용이 좀 든다.

 

 

자바스크립트의 작성

www/plugin.js의 코드를 살펴보자

echo, getDate를 함수로 갖는 간단한 객체를 정의하고 있다. 실행 시 에 개발자는 다음과 같이 플러그인을 호출할 수 있다.

 

window.MyCordovaPlugin.echo('hello!', function() { // callback

});

 

이코드가 실행되는 순간 마법이 있어나게 되며 안드로이드 혹은 iOS의 네이티브 코드가 실행되어지고 그 결과를 콜백으로 받을 수 있다.

 

 

iOS 네이티브 작성

objc code파트이다. 헤더를 먼저 보자

 

이 헤더파일은 m파일과 대응된다.

 

이 메서드들은 js의 exec()가 실행될 때 호출된다. CDVInvokedUrlCommand 인자가 js로부터 전달한 인자를 넘겨주게 된다. 콜백은 한번만 사용할 지 반복적으로 사용([result setKeepCallbackAsBool]을 호출하여)할지 정할 수 있다.

 

결과를 반환해주려면 CDVPluginResult 객체를 만들고 commandDelegate로 넘겨주면 js까지 전달된다.

 

Android 플러그인 작성

iOS와 컨셉은 동일하다 문법적으로 약간 다를뿐. 다음 코드를 보자 src/android/com/example/MyCordovaPlugin.java

execute메서드 하나에서 action인자로 echo와 getDate메서드를 분기하여 처리하고 있다. 결과를 반환하는 방식은 비슷하다.

 

플러그인 테스트

타이핑 끝났으면 테스트를 하자. 

코도바플러그인을 테스트하려면 Cordova/PhoneGap/Ionic앱이 실행하기 위해 있어야 한다. 단독으로 동작하지 않는다.

 

Cordova 앱이 있다고 가정하면 다음과 같이 로컬에서 플러그인을 추가할 수 있다.

 

cordova plugin add --link ~/git/echo-plugin

 

--link플래그는 심볼릭링크로 플러그인을 추가하는것이며 플러그인을 다시 추가하지 않고 코드를 수정하고 빌드하고 실행할 수 있다는것을 의미한다. 하지만 javascript파트의 코드는 자동으로 업데이트 되지 않을수 있다. 이 때는 cordova rm my-cordova-plugin으로 빠르게 삭제하고 다시 추가하면 된다.

 

여기까지 기존 플러그인을 수정하여 적용하는 방법을 알아 봤다.

이는 좀 해키한 방법이며 권장하는 방법은 아니다.. 따라서 별로 이렇게 하고 싶지는 않다. 일을 빨리 하기 위해서는 이 방법도 괜찮겠지만 plugman으로 하는 방법에 대해서도 정리해서 포스팅할 생각이다!!

 

 

 

Posted by 삼스

댓글을 달아 주세요

Android/App개발2019. 6. 10. 14:15

대거2를 적용하는 3 가지 방법이 있다.

 

1번은 Component, Module, Scope으로 직접 모두 기술하는 방법이고

2번은 DispatchingAndroidInjector로 제공하는 방법

3번은 안드로이드에서 제공하는 기반클래스(DaggerActivity, DaggerFragment, ...)로 제공하는 방법이 있다.

 

여기서는 1번 방식으로 작업하는 방식을 설명한다.

여러가지 구성을 하는 방법이 있겠지만 내가 작업한 방식을 설명한다. 틀린 부분이 있다면 누구든 지적을 해주었으면 한다.

 

안드로이드에서 대거는 전역 및 로컬범위로 다양하게 scope을 지정하여 객체를 주입할 수 있다.

Application레벨은 보통 전역 객체를 Activity레벨은 로컬객체를 주입한다.

 

전역에서 GuiManager를 로컬에서 ItemAdapter를 주입할것이다. 

 

Module을 정의한다.

 

in AppModule.java

 

@Module

public class AppModule {

  private MyApplication mApp;

  public AppModule(MyApplication app) { mApp = app; }

  

  @Provides

  @Singletone

  GuiManager provideGuiManager() { return new GuiManager(); }

}

 

MyApplication을 멤버로 가지고 있으며 Scope을 Singletone으로 GuiManager를 주입하기 위한 Provider를 구현한다.

provide를 prefix로 하여 메서드를 정의하며 해당 클래스의 인스턴스를 생성하여 반환한다.

 

Component를 구현한다.

 

in AppComponent

 

@Singletone

@Component(modules = { AppModule.class }

public interface AppComponent {

  void inject(MyApplication app);

  void inject(MainActivity activity);

}

 

Application에서 GuiManager를 주입하는 예이다.

in MyApplication.java

 

public class MyApplication extends Application {

 

  AppComponent mComponent;

 

  @Inject

  protected GuiManager mGuiManager;

 

  @Override

  public void onCreate() {

    super.onCreate();

    mComponent = DaggerAppComponent.builder().appModule(new AppModule()).build();

    mComponent.inject(this);

  }

 

  public AppComponent getComponent() {

    return mComponent;

  }

 

대거는 주석을 기반으로 코드를 생성하며 Dagger를 prefix로하여 Component builder로 객체를 생성할 수 있다. 이렇게 만들어진 ㅡㅐ여component의 inject()를 호출하면 Module에서 provide prefix로 노출한 객체들이 바인딩되어 진다. 

 

이번에는 액티비티 스콥의 주입예이다. ItemAdapter를 MainActivity에서 주입하여 사용할것이다.

 

ActivityModule을 정의한다.

 

@Module

public class ActivityModule {

  private Activity mActivity;

  public ActivityModule(Activity activity) {
    mActivity = activity; 

  }

  

  @Provides @ActivityScope

  Activity activity() { return mActivity; }

 

  @Provides @ActivityScope

  ItemAdapter provideItemAdapter() {

    return new itemAdapter();

  }

}

 

provide prefix로 itemAdapter를 노출하고 있다.

ActivityComponent를 구현한다.

 

@ActivityScope

@Component(dependencies={AppComponent.class}, modules={ActivityModule.class})

public interface ActivityComponent {

  void inject(Activity activity);

}

 

dependencies를 추가하였다. AppComponent를 정의하여 GuiManager도 사용이 가능하다.

MainActivity에서 주입을 시전한다.

 

public class MainActivity extends AppCompatActivity {

  @Inject

  GuiManager guiManager;

  @Inject

  ItemAdapter itemAdapter;

 

  @Override

  public void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);

 

    ((MyApplication)getApplication()).getComponent().inject(this);

    DaggerActivityComponent activityComponent = DaggerActivityComponent.builder().appComponent(new AppComponent()).build();

    activityComponent.inject(this);

 

    guiManager.showAlert("hi!");

    itemAdapter.setDataSource(new MySource()); 

  }

  ...

}

 

MyApplication의 getComponent()를 가져와서 inject함으로써 GuiManager가 주입되었고 DaggerActivityComponent를 build하여 ItemAdapter를 주입하였다.

이 후 guiManager.showAlert("hi")나 itemAdapter.setDataSource(new MySource()) 같이 주입된 객체를 사용할 수 있다.

guiManager는 singletone의 스콥을 가지며 itemAdapter는 ActivityScope을 가진다.

 

ActivityScope이 무엇인가 싶을텐데.. 아래와 같이 정의된다.

 

@Scope

@Retention(RUNTIME)

public @interface ActivityScope {}

 

Scope을 하나 정의했는데 저리하면 액티비티에 종속되는 범위를 갖는 스콥 아노테이션이 만들어진다. 아노테이션 세계는 참..

 

의존성을 여러개로 나누어서도 관리할 수 있다. 모듈과 콤포넌트를 용도에 맞게 구성하여 사용하면 된다.

이번에는 UserData를 주입하기 위한 예제를 살펴보겠다.

 

@Module

public class UserModule {

  private Activity mActivity;

  public UserModule(Activity act) { mActivity = act; }

 

  @Provides @ActivityScope

  Activity activity() { return mActivity; }

 

  @Provides @ActivityScope

  UserData provideUserData() { reutrn new UserData(); }

}

UserData를 주입하기 위해 provideUserData메서드가 정의되었다.

 

@ActivityScope

@Component(dependencies={AppComponent.class}, modules={ActivityModule.class, UserModule.class})

public interface UserComponent {

  void inject(Activity activity);

}

 

AppComponent, ActivityModule등의 의존성도 포함하고 있으며 주입을 위해 inject가 정의되어 있다.

이 모듈을 사용하기 위해 SubActivity는 다음과 같이 구현된다.

 

public class SubActivity extends Activity {

  @Inject

  ItemAdapter itemAdapter;

  @Inject

  UserData userData;

 

  @Override

  public onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    DaggerActivityComonent.builder().appComponent((MyApplication)getApplication()).getComponent()).build().inject(this);

    DaggerUserData.builder().appComponent((MyApplication)getApplication()).getComponent()).build().inject(this);

  }

  ...

}

 

itemAdapter를 사용하기 위해 DaggerActivityComponent.builder()를 사용했고 userData를 사용하기 위해 DaggerUserData.builder()를 사용했다.

 

이와 같이 전역 및 지역적으로 객체를 주입해서 사용하는 일반적인 방법을 알아 보았다.

 

이 방법은 GuiManager, ItemAdapter, UserData등에 대해 모두 정확히 알고 있어야 하며 코드도 많다. 이 보다 적은 코드로도 적용이 가능한데 위에서 말한대로 두가지 방법이 더 있다. 이 에 대해서는 추가로 공부하여 정리하도록 할것이다.

 

 

 

Posted by 삼스

댓글을 달아 주세요

Android/App개발2019. 6. 10. 11:03

Dagger and android

 

https://dagger.dev/android

 

Dagger2 다른 의존성주입 프레임웍들에 비해 주요장점중에 하나는 엄격하게 만들어졌다는것이며 이는 안드로이드앱에서도 사용될 있음을 의미한다. 하지만 대거를 안드로이드 앱에서 사용하기 위해서는 고려할것들이 있다.

 

안드로이드가 자바로 작성이 되지만 스타일면에서 다르다. 보통 이런 차이점은 모바일의 성능고려를 수용하기 위해 존재한다.

하지만 많은 패턴들이 이와는 반대인 경우가 많다. Effective Java 많은 어드바이스들이 안드로이드에 적절하게 적용가능하다.

 

이런 목표를 달성하기 위해 대거는 컴파일된 바이트코드를 후처리하기 위해 프로가드에 의존한다. 이는 대거가 코드를 서버와 안드로이드 둘다 자연스럽게 코드를 만들어낼 있게 한다. 서로 다른 툴체인과 바이트코드를 만들어냄에도 불구하고

대거는 이른 보장하기 위해 프로가드 최적화에 호환되는 코드를 만들어낸다.

따라서 대거는 프로가드를 사용해야 한다.

 

Recommended ProGuard Settings

 

dagger.android

 

대거를 사용하는 안드로이드앱을 작성하는 가장 어려움중에 하나는 액티비티나 프래그먼트같은 안드로이드 프래임웍 클래스들이 OS 의해서 인스턴스화되지만 대거는 삽입된 모든 객체를 생성할 있는 경우 가장 잘동작한다는것이다. 대신에 생명주기 메서드내에서 멤버주입을 수행해야 한다. 이는 많은 클래스들이 다음의 형태와 같다는것을 의미한다.

 

public class FrombulationActivity extends Activity {

  @Inject Frombulator frombulator;

 

  @Override

  public void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    // 작업을 먼저 하지 않으면 frombulator null일것이다.

    ((SomeApplicationBaseType) getContext().getApplicationContext())

        .getApplicationComponent()

        .newActivityComponentBuilder()

        .activity(this)

        .build()

        .inject(this);

    // ... now you can write the exciting code

  }

}

 

이는 몇가지 문제가 있다.

 

  1. 복사붙이기가 나중에 리팩터링하기 힘들다. 많은 개바자들이 그렇게들 하는데 일부만 멀하는지 이해한다.
  2. 근본적으로 이는 타입요청 주입이다. 이는 인젝터가 타입을 알아야 한다. 각각 타입이 아니라 인터페이스를 통해 이른 해결한다 해도 이는 의존성주입의 핵심원리를 깬다. 클래스는 어떻게 주입되는지 아무것도 몰라야 한다.

 

dagger.android 클래스들은 패턴을 단순화하기 위한 하나의 접근법을 제공한다.

 

 

Injecting Activity objects

 

  1. 애플리케이션 구성요소에 AndroidInjectionModule 설치해서 이러한 기본 유형에 필요한 모든 바인딩을 사용할수 있도록 하라.
  2. AndroidInjector<YoutActivity> 구현하는 @Subcomponent작성을 시작해라.  AndroidInjector.Factory<YourActivity> 확장한 @Subcomponent.Factory 있다.

 

@Subcomponent(modules = ...)

public interface YourActivitySubcomponent extends AndroidInjector<YourActivity> {

  @Subcomponent.Factory

  public interface Factory extends AndroidInjector.Factory<YourActivity> {}

}

 

3. 서브콤포넌트를 정의하고 나서 모듈을 정의하여 콤포넌트 구조를 추가해라. 모듈은 서브콤포넌트 팩토리를 바인딩하여 애플리케이션에 주입할 콤포넌트를 추가한다.

 

@Module(subcomponents = YourActivitySubcomponent.class)

abstract class YourActivityModule {

  @Binds

  @IntoMap

  @ClassKey(YourActivity.class)

  abstract AndroidInjector.Factory<?>

      bindYourActivityInjectorFactory(YourActivitySubcomponent.Factory factory);

}

 

@Component(modules = {..., YourActivityModule.class})

interface YourApplicationComponent {}

 

2단계에서와 달리 서브콤포넌트와 팩토리가 메서드나 수퍼타입을 갖고 있지 않은 경우 @ContributesAndroidInjector 사용할 있다. 2, 3단계대신에 abstract모듈 메세드를 @ContributesAndroidInjector 함께 추가하여 당신의 액티비티를 반환할 있다. 그리고 서브콤포넌트에 설치하고자 하는 모듈을 기술하라.

서브콤포넌트가 스콥이 필요하면 스콥주석을 사용할수 있다

 

 

@ActivityScope

@ContributesAndroidInjector(modules = { /* modules to install into the subcomponent */ })

abstract YourActivity contributeYourActivityInjector();

 

4. 이제 당신의 애플리케이션에 HasActivityInjector 구현하고 @Inject  DispatchingAndroidInjector<Activity> 지정하여 activityInjector()로부터 반환한다. 

 

public class YourApplication extends Application implements HasActivityInjector {

  @Inject DispatchingAndroidInjector<Activity> dispatchingActivityInjector;

 

  @Override

  public void onCreate() {

    super.onCreate();

    DaggerYourApplicationComponent.create()

        .inject(this);

  }

 

  @Override

  public AndroidInjector<Activity> activityInjector() {

    return dispatchingActivityInjector;

  }

}

 

5. 마지막으로 Activity.onCreate()메서드에서 AndroidInjection.inject(this) super.onCreate()호출전에 호출한다.

 

public class YourActivity extends Activity {

  public void onCreate(Bundle savedInstanceState) {

    AndroidInjection.inject(this);

    super.onCreate(savedInstanceState);

  }

}

 

 

어떻게 동작하나?

 

AndroidInjection.inject() Application으로부터 DispatchingAndroidInjector<Activity> 얻고 inject(Activity) 액티비티에 전달된다. 

DispatchingAndroidInjector 당신의 액티비티의 클래스(YourActivitySubcomponent.Factory) 위해 AndroidInjector.Factory 찾고, AndroidInjector(YourActivitySubComponent) 생성하고, inject(yourActivity) 당신의 액티비티를 전달한다.

 

프래그먼트 객체의 주입

 

프래그먼트를 주입하는것은 액티비티를 주입하는것 만큼 단순하다. 같은 방식으로 서브콤포넌트를 정의하고 HasActivityInjector HasFragmentInjector 변경하면 된다.

 

onCreate()에서 액티비티를 주입하는것 대신에 onAttach(..)에서 주입하면 된다.

 

액티비티에 정의된 모듈과 달리, 프래그먼트에 모듈을 설치할 위치를 선택할수 있다. 당신의 프래그먼트콤포넌트를 다른 프래그먼트 콤포넌트, 액티비티 콤포넌트 또는 애플리케이션 콤포넌트의 서브콤포넌트로 만들수 있다. 이는 당신의 프래그먼트를 필요로 하는 다른 바인딩에 의존한다. 콤포넌트의 위치를 결정하고 나서 대응되는 타입의 HasFragmentInjector 구현한다. 예를 들어 당신의 프래그먼트가 YourActivitySubcomponent에서 바인딩이 필요하면 다음과 같이 코딩할것이다.

 

public class YourActivity extends Activity

    implements HasFragmentInjector {

  @Inject DispatchingAndroidInjector<Fragment> fragmentInjector;

 

  @Override

  public void onCreate(Bundle savedInstanceState) {

    AndroidInjection.inject(this);

    super.onCreate(savedInstanceState);

    // ...

  }

 

  @Override

  public AndroidInjector<Fragment> fragmentInjector() {

    return fragmentInjector;

  }

}

 

public class YourFragment extends Fragment {

  @Inject SomeDependency someDep;

 

  @Override

  public void onAttach(Activity activity) {

    AndroidInjection.inject(this);

    super.onAttach(activity);

    // ...

  }

}

 

@Subcomponent(modules = ...)

public interface YourFragmentSubcomponent extends AndroidInjector<YourFragment> {

  @Subcomponent.Factory

  public interface Factory extends AndroidInjector.Factory<YourFragment> {}

}

 

@Module(subcomponents = YourFragmentSubcomponent.class)

abstract class YourFragmentModule {

  @Binds

  @IntoMap

  @ClassKey(YourFragment.class)

  abstract AndroidInjector.Factory<?>

      bindYourFragmentInjectorFactory(YourFragmentSubcomponent.Factory factory);

}

 

@Subcomponent(modules = { YourFragmentModule.class, ... }

public interface YourActivityOrYourApplicationComponent { ... }

 

 

Base Framework Types

 

DispatchingAndroidInjector 런타임에 해당클래스가 전용 AndroidInjector.Factory 찾기 때문에 기반클래스는 AndroidInjection.inject() 호출하고 HasActivityInjector/HasFragmentInjector/등을 구현해야 한다. 모든 서브클래스들이 해야 하는 일은 대응되는 @Subcomponent 바인딩해야 하는것이다. 대거는 복잡한 클래스구조가 없다면 DaggerActivity DaggerFragment같은 몇가지 기반클래스를 제공한다. 대거는 같은 목적으로 DaggerApplication 제공한다. 당신이 해야 일은 이를 확장하고 applicationInjector()메서드를 오버라이드하여 application 주입하는 콤포넌트를 반환한다.

 

다음 타입들 또한 제공된다

 

  • DaggerService DaggerIntentService
  • DaggerBroadcastReceiver
  • DaggerContentProvider

 

DaggerBroadcastReceiver AndroidManifest.xml 등록되어 있어야 한다. 

코드로 BroadcastReceiver 생성되면 대신에 생성자주입을 선호합니다.

 

지원라이브러리는 dagger.android.support 패키지이다

 

Build.gradle 다음을 추가해야 한다.

 

dependencies {

  compile 'com.google.dagger:dagger-android:2.x'

  compile 'com.google.dagger:dagger-android-support:2.x' // if you use the support libraries

  annotationProcessor 'com.google.dagger:dagger-android-processor:2.x'

}

 

 

When to inject

 

생성자 주입은 가능하면 선호된다. javac 셋팅되기전에 필드가 참조되지 않아서 널포인트를 피할수 있도록 해주기 때문에 선호된다.

멤버주입이 필요한 경우(위에서 언급된) 가능하면 빨리 주입하는것이 선호된다. DaggerActivity super.onCreate() 호출되기 전에 AndroidInjection.inject() 바로 호출하기 때문에 선호된다. 프래그먼트의 경우는 onAttach()에서 한다.

 

super.onCreate()보다 전에 AndroidInjection.inject() 먼저 호출하는것이 중요하다. 반대로 하면 컴파일에러가 발생한다.

 

Posted by 삼스

댓글을 달아 주세요

Android/App개발2019. 6. 5. 16:44

https://dagger.dev/users-guide

 

Dagger FactoryFactory 클래스를 대체한다. 보일러플레이트를 배제한 의존성주입을 구현한다. 이는 쓸모없는 오버엔지니어링을 방지하고 의미 있는 클래스에 집중할수 있게 한다. 의존성을 정의하고 어떻게 구성되는지 기술하면 된다.

 

테스트 아주 유용할뿐 아니라 재사용 가능하고 모듈의 변경이 가능하다. AuthenticationModule 여러 앱에서 사용 가능하고 DebugLoggingModule ProdLoggingModule 상황에 맞게 구성하여 사용할 있다.

 

Dagger2 최초료 풀스택 코드생성방식으로 구현되었다. 

 

커피메이커 샘플(https://github.com/google/dagger/tree/master/examples/simple/src/main/java/coffee) 대거를 설명하겠다.

 

대거는 당신의 클래스들과 이에 관련된 의존성을 정의하는 것으로 구성이 된다. Javax.inject.Inject 어노테이션으로 생성자와 필드를 지정한다.

 

클래스 생성자에 @Inject 사용하면 대거가 클래스인스턴스를 만들때 사용한다. 새로운 인스턴스를 요청하면 요구되는 파라메터들을 얻어내어 생성자를 만든다.

 

class Thermosiphon implements Pump {

  private final Heater heater;

 

  @Inject

  Thermosiphon(Heater heater) {

    this.heater = heater;

  }

 

  ...

}

 

대거는 필드를 바로 주입할수 있다. 다음 샘플은 두개의 필드를 얻어낸다.

 

class CoffeeMaker {

  @Inject Heater heater;

  @Inject Pump pump;

 

  ...

}

 

클래스가 @Inject 필드는 있는데 생성자가 @Inject 없다면 대거는 필요하면 필드를 주입하게 되겠지만 새로운 인스턴스를 생성하지는 않을 것이다.  인자가 없는 생성자를 추가해서 대거가 인스턴스를 생성할 있게 해주어야 한다.

 

메서드 주입도 지원하는데 생성자나 필드주입이 선호된다.

 

@Inject아너테이션이 없는클래스는 대거가 생성할 없다.

 

기본적으로 위에서 기술한 타입의 인스턴스를 생성함으로써 의존성을 만족시킨다. CoffeeMaker 요청하면  new CoffeeMaker() 인스턴스를 만들고 필드에 주입하도록 설정한다.

 

@Inject 항상 동작하지는 않는다.

  • Interface 생성될수 없다.
  • 3rd party 클래스는 어도테이션할수 없다.
  • 설정가능한 객체는 반드시 설정하여 사용해야 한다.

 

@Providers 어노테이션은 메서드에 의존성을 부여한다. 해당 메서드의 반환타입이 의존성객체이다.

 

예를 들어 provideHeader() Header 필요할대 마다 호출된다.

 

@Module

class DripCoffeeModule {

  @Provides static Heater provideHeater() {

    return new ElectricHeater();

  }

 

  @Provides static Pump providePump(Thermosiphon pump) {

    return pump;

  }

}

 

 

@Inject @Provides 어노테이트된 클래스는 의존성에 따른 객체 그래프를 만든다. main메서드나 안드로이드의 Application 그래프의 루트로 사용될수 있다.

 

대거2에서 의존성은 다음 샘플처럼 인수가 없고 원하는 형식을 반환하는 메서드가 있는 인터페이스로 정의되며 @Component주석과 모듈유형을 매개변수로 전달한다. 그러면 명세에 따라 코드가 생성된다.

 

@Component(modules = DripCoffeeModule.class)

interface CoffeeShop {

  CoffeeMaker maker();

}

 

프리픽스로 Dagger 붙은 동일한 이름의 클래스가 생성되며 builder().build()메서드로 인스턴스를 얻는다.

 

CoffeeShop coffeeShop = DaggerCoffeeShop.builder()

    .dripCoffeeModule(new DripCoffeeModule())

    .build();

 

콤포넌트가 최상위타입이 아니면 생성된 콤포넌트 이름은 타입의 이름을 포함하여 밑줄로 구분하여 이름이 정해진다.

 

class Foo {

  static class Bar {

    @Component

    interface BazComponent {}

  }

}

 

경우 DaggerFoo_Bar_BazComponent

 

접근가능한 생성자를 갖는 모듈은 builder 생략될 있다. 

모든 @Provides메서드가 static이면 인스턴스의 구현이 필요없다. 때도 create()메서드로 builder없이 생성이 가능하다.

 

CoffeeShop coffeeShop = DaggerCoffeeShop.create();

 

커피앱에서 대거가 생성한 구현체가 주입된 CoffeeShop객체를 사용하는 예이다.

 

public class CoffeeApp {

  public static void main(String[] args) {

    CoffeeShop coffeeShop = DaggerCoffeeShop.create();

    coffeeShop.maker().brew();

  }

}

 

샘플은 콤포넌트를 어떻게 생성하는지에 대한 몇가지 방법을 설명한다. 다른 바인딩방법을 알아보자

 

다음은 의존성으로 사용 가능하며 구성된 콤포넌트를 생성하는데 사용될 있다.

 

  • @Component.modules 의해 직접 참조되거나 @Module.includes 통해 참조죄는 @Module내에 @Provides메서드로 선언된 모듈
  • scope 지정되지 않는 @Inject생성자가 있는 타입이거나 콤포넌트 scope 일치하는 @Scope 주석이 있는 타입
  • 콤포넌트 의존성의 콤포넌트 제공 메서드
  • 콤포넌트 자체
  • 임의의 포함된 서브콤포넌트의 규정되지 않는 빌더
  • Provider 또는. Lazy wrapper 
  • Lazy Provider( Provider<Lazy<CoffeeMaker>>)
  • 모든 타입의 memberInjector

 

 

@Singletone주석을 갖는 @Provides 단일인스턴스를 사용한다.

 

@Provides @Singleton static Heater provideHeater() {

  return new ElectricHeater();

}

 

싱글톤을 사용할떄는 멀티스레드에 대해 대비해야 한다.

 

@Singleton

class CoffeeMaker {

  ...

}

 

대거2 콤포넌트 구현 범위를 연관시키기 때문에 이를 선언해야 한다. @Singletone @RequestScoped바인딩을 동일한 콤포넌트에 포함하는것은 의미가 없다. 수명주기가 다르기 때문인데 유의하여 콤포넌트 인터페이스 정의 범위 주석을 적용해야 한다.

 

@Component(modules = DripCoffeeModule.class)

@Singleton

interface CoffeeShop {

  CoffeeMaker maker();

}

 

콤포넌트는 여러 범위 주석을 적용할 있다. 

 

 

간혹 @Inject 생성되는 클래스가 @Provides메서드로 인스턴스로 만드는데 회수를 제한하고자 할수 있다. 하지만 모든 개개의 콤포넌트나 서브콤포넌트에서 사용되는 인스턴스가 동일한지 보장할 필요 없다. 이는 안드로이드 같은 메모리가 비용이 비싼 경우 유용하다.

 

경우 @Reusable 범위를 사용할 있다. @Reusable 사용되면 다른 범위와 다르게 모든 단일 콤포넌트에 연관되지 않는다 대신에 바인딩을 실제로 사용하는 콤포넌트들은 캐시하거나 객체를 생성한다.

 

이는 콤포넌트에 @Reusable 바인딘된 모듈을 정의하고 서브콤포넌트만 실제 해당 바인딩을 사용한다면 서브콤포넌트는 해당 바인딩을 캐시하게 된다. 조상을 공유하지 않는 두개의 서브콤포넌트가 바인딩 한다면 각각 따로 캐시할것이다. 조상이 이미 객체를 캐시한 경우 서브컴포넌트는 재사용한다.

 

콤포넌트가 바인딩을 한번만 호출한다는 보장이 안되므로 변경가능한 객체를 반환하는 바인딩에 @Reusable 적용하거나 동일 인스턴트를 참조하는것은 위험하다. 할당 횟수와 상관없는 불변객체에 대해 사용하는것이 안전하다.

 

@Reusable // It doesn't matter how many scoopers we use, but don't waste them.

class CoffeeScooper {

  @Inject CoffeeScooper() {}

}

 

@Module

class CashRegisterModule {

  @Provides

  @Reusable // DON'T DO THIS! You do care which register you put your cash in.

            // Use a specific scope instead.

  static CashRegister badIdeaCashRegister() {

    return new CashRegister();

  }

}

 

@Reusable // DON'T DO THIS! You really do want a new filter each time, so this

          // should be unscoped.

class CoffeeFilter {

  @Inject CoffeeFilter() {}

}

 

Lazy injections

 

지연된 주입이 가능하다. 샘플 참조.

 

class GrindingCoffeeMaker {

  @Inject Lazy<Grinder> lazyGrinder;

 

  public void brew() {

    while (needsGrinding()) {

      // Grinder created once on first call to .get() and cached.

      lazyGrinder.get().grind();

    }

  }

}

 

Provider Injections

 

여러개의 인스턴스가 필요한 경우가 있을 것이다. 경우 사용이 가능하다.

 

class BigCoffeeMaker {

  @Inject Provider<Filter> filterProvider;

 

  public void brew(int numberOfPots) {

  ...

    for (int p = 0; p < numberOfPots; p++) {

      maker.addFilter(filterProvider.get()); //new filter every time.

      maker.addCoffee(...);

      maker.percolate();

      ...

    }

  }

}

 

 

Qualifier

 

같은 클래스의 다른 인스턴스가 필요한 경우가 있다. 경우 qualifier주석을 사용할 있다. 

 

@Qualifier

@Documented

@Retention(RUNTIME)

public @interface Named {

  String value() default "";

}

 

자신만의 qualifier 만들거나 그냥 @Named 사용할수 있다. 필드와 관심있는 파라메터에 모두 사용가능하다.

 

class ExpensiveCoffeeMaker {

  @Inject @Named("water") Heater waterHeater;

  @Inject @Named("hot plate") Heater hotPlateHeater;

  ...

}

 

대응되는 @Provides메서드가 제공되어야 한다.

 

@Provides @Named("hot plate") static Heater provideHotPlateHeater() {

  return new ElectricHeater(70);

}

 

@Provides @Named("water") static Heater provideWaterHeater() {

  return new ElectricHeater(93);

}

 

 

Optional bindings

 

콤포넌트에 포함되지 않음에도 디펜던시를 추가하고 싶다면 @BindsOptionalOf 사용할 있다.

 

@BindsOptionalOf abstract CoffeeCozy optionalCozy();

 

이는 @Inject생성자와 멤버 그리고 @Provides메서드는 Optional<CoffeeCozy>객체에 의존한다. 콤포넌트에  CoffeeCozy 바인딩되어 있으면 Optional 존재하고 없으면 존재하지 않을것이다.

 

다음중 하나를 주입할수 있다.

 

  • Optional<CoffeeCozy> : CoffeeCozy 바인딩에 @Nullable 없다면(아래 참조)
  • Optional<Provider<CoffeeCozy>>
  • Optional<Lzay<CoffeeCozy>
  • Optional<Provider<Lazy<CoffeeCozy>>>

 

Provider, Lazy 또는 Lazy Provider 주입할수 있지만 유용하지는 않다.

 

CoffeeCozy바인딩이 있고 바인딩이 @Nullable이면 Optional<CoffeeCozy>에서 컴파일에러가 발생한다. 왜냐하면 Optional null일수 없기 때문이다. Provider Lazy get 메서드에서 항상 null 반환할 있기 때문에 항상 다른 값이 주입될 있다.

 

콤퍼넌트에 optional 바인딩이 없어도 서브콤포넌트에 있을 있다. 서브콤포넌트에 기저타입의 바인딩이 있다면

 

 

Binding Instances

 

종종 콤포넌트를 빌드하는 시점에 유효한 데이터를 가질수 있다. 예를 들어 커맨드라인 인자를 필요로 하는 앱이 있는 경우 콤포넌트에 인자를 전달하고자 할것이다.

 

단일 인자로 이름을 받고 @UserName문자열로 주입하고자 한다면 콤포넌트 생성시 값을 전달하기 위해 @BindsInstance 주석을 추가할수 있다.

 

@Component(modules = AppModule.class)

interface AppComponent {

  App app();

 

  @Component.Builder

  interface Builder {

    @BindsInstance Builder userName(@UserName String userName);

    AppComponent build();

  }

}

 

위와 같이 정의하고 앱에서는 아래와 같이 사용한다.

 

public static void main(String[] args) {

  if (args.length > 1) { exit(1); }

  App app = DaggerAppComponent

      .builder()

      .userName(args[0])

      .build()

      .app();

  app.run();

}

 

콤포넌트에 주입되는 @UserName 문자열은 메서드가 호출될 빌더에 제공되는 인스턴스에 사용하게 될것이다. 콤포넌트를 빌드하기 전에 모든 @BindsInstance메서드들이 반드시 호출되어야 하면 null 아닌값이 전달되어야 한다(@Nullable 바인딩의 경우 제외).

 

@BindsInstance메서드가 @Nullable 경우 바인딩은 @Provides메서드의 경우처럼 nullable 간주된다. @Nullable 해야 하며 떄는 바인딩에 null 허용된다. Builder 유저는 호출을 생략할수 있으며 경우 콤포넌트는 null 다루어진다.

 

@BindsInstance메서드는 @Module 생성자 인자로 작성되어야 하고 해당 값이 바로 제공되어져야 한다.

 

Compile-time Validation

 

대거 아노테이션 프로세서는 업격해서 유효하지 않거나 완성되지 않는 바인딩에 대해 컴파일에러를 발생한다. 예를 들면 다음 예는 Executor 위한 바인딩이 누락상태의 모듈을 콤포넌트에 인스톨하고 있다.

 

@Module

class DripCoffeeModule {

  @Provides static Heater provideHeater(Executor executor) {

    return new CpuHeater(executor);

  }

}

 

컴파일하면 javac 바인딩 누락으로 반려하게 된다.

 

[ERROR] COMPILATION ERROR :

[ERROR] error: java.util.concurrent.Executor cannot be provided without an @Provides-annotated method.

 

콤포넌트내의 아무 모듈에든 executor 위한 @Provides 주석을 추가해서 문제를 해결할 있다. @Inject, @Module그리고 @Provides주석이 각각 유효하면 @Component단계에서 바인딩간의 관계에 대한 모든 유효성검사가 발생한다. 대거1 모듈단계에서 유효성이 업격하게 책임지없다면 대거2 단계는 생략한다.

 

Compile time Code Generation

 

대거는 컴파일 CoffeeMaker_Factory.java CoffeeMaker_MembersInjector.java같은 이름의 파일들을 만들어 낸다. 파일들은 대거 구현의 디테일이다. 이들을 바로 사용할일은 없으며 디버깅은 해볼수 있겠다.코딩 참조할만한 코드들은 콤포넌트에 프리픽스로 Dagger 붙이것들이다.

 

Using Dagger In Your Build

 

Dagger-2.x.jar 런타임에 필요하다.  dagger-compiler-2.x.jar 코드자동생성을 위해 요하다. 자새한것은 다음 링크 참조 https://github.com/google/dagger/blob/master/README.md#installation

 

Posted by 삼스

댓글을 달아 주세요

Android/App개발2019. 6. 4. 14:02

https://github.com/google/dagger

 

google/dagger

A fast dependency injector for Android and Java. Contribute to google/dagger development by creating an account on GitHub.

github.com

의존성주입 라이브러리인 Dagger2를 알아보기 전에 Dagger1을 먼저 알아보자


2012년에 자바로 의존성을 주입하는 아이디어를 좋아한 스퀘어 개발자 몇명이 만들었다. 결국 어노테이션 기반의 코드생성과 guice와 비슷한 api를 갖지만 더 유연하고 빠르게 만들었다.
Dagger의 동작방식은 주입하고자 하는 모든 의존성을 위한 프로바이더를 포함하는 모듈들을 정의하여 객체그래프에 모듈을 로딩하고 결국 필요한 타겟에 내용을 주입하는 방식이다. 충분히 단순한구조(구현은 단순하지 않음)는 개발자가 코드를 분리할 수 있게 도움을 주고 클래스 상단에 객체를 생성하는 보기싫은 코드들을 라이브러리가 생성하는 인젝터들에 옮겨준다.
하지만 이런 잇점과 동시에 빠른 풀리퀘스트(하나 혹은 둘)를 해결하지 못하는 문제가 있다. 이는 기본아키텍쳑와 관련되어 있다.

- 런타임에 그래프 구성 : 성능에 악영향. 
- 리플랙션(예:Class.forName()) : 읽기 힘든 자동생성 코드와 프로가드의 악몽 발생
- 보기 싫은 자동생성코드 : 팩토리로 부터 수동 생성한 경우와 비교하여 아주 보기 싫음

결국 이런 이유로 수많은 이슈들이 트래킹되었고 이 이슈들은 Dagger2에서 해결하는것으로 이슈가 클로즈 되었다.

Dagger2

스퀘어의 원작자와 구글의 코어라이브러리 팀이 Dagger의 다음 이터레이션을 가져왔다.
약속대로 여러 이슈들이 해결되어 새버전이 배포되었다.

- 리프랙션 없음 : 프로가드 지옥도 해결
- 런타입 그래프구성 없음 : 성능 향상
- 추적가능 : 더 좋은 코드와 리플랙션 제거로 인해 더 읽이 쉽고 따라하기 쉬워짐.

Module

Dagger2에서 가장 변경이 없는것이 모듈이다. 주입하고자 하는 의존성의 프로바이더 메서드를 정의하면 된다. 

SharedPreference가 필요하다고 외쳐보자!

@Module 
public class ApplicationModule { 
    private Application mApp; 
    public ApplicationModule(Application app) { 
        mApp = app; 
    } 
    @Provides
    @Singleton
    SharedPreferences provideSharedPrefs() { 
        return PreferenceManager.getDefaultSharedPreferences(mApp); 
    } 
}

Component

Dagger를 아는 사람은 모듈에서 ingect = {} 가 사라진것을 알수 있다. Dagger2는 콤포넌트가 이를 대체한다.

@Singleton 
@Component(modules = {ApplicationModule.class}) 
public interface ApplicationComponent { 
    void inject(DemoApplication app); 
    void inject(MainActivity activity); 
}

주입하고자 하는 타겟들을 정의하면 되며 만일 누락되면 "cannot find method" 컴파일에러가 날것이다.

Application

다음은 콤포넌트를 담을 컨테이너이다.
응용 프로그램에 따라 더 복잡한 방법으로 구성 요소를 저장할 수도 있지만이 예제에서는 응용 프로그램 클래스에 저장된 단일 구성 요소로 충분하다.

public class DemoApplication extends Application { 
    private ApplicationComponent mComponent; 
    @Override 
    public void onCreate() { 
        super.onCreate(); 
        mComponent = DaggerApplicationComponent.builder() 
                    .applicationModule(new ApplicationModule(this))
                    .build(); 
    } 
    public ApplicationComponent getComponent() { 
        return mComponent; 
    } 
}

특별한것이 없다 해당 콤포넌트를 build하고 인스턴스화 해서 저장한다.
위 코드에서 이해가 안되는 부분이 있을수 있는데 DaggerApplicationComponent가 어디서 나왔냐 하는것일것이다. 이는 Dagger%COMPONENT_NAME%형식으로 명명되어 자동생성된 클래스이다. 컴파일러가 자동으로 만들어준다. 

Injection

마지막으로 위에서 설정한 인젝션 설정을 SharedPreference에 접근하고자 하는 액티비티내에서 사용하게 된다.

public class MainActivity extends Activity { 
    @Inject SharedPreferences mSharedPrefs; 
    @Override 
    public void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState); 
        ((DemoApplication) getApplication())
                    .getComponent()
                    .inject(this); 
        mSharedPrefs.edit()
                    .putString("status", "success!")
                    .apply(); 
    } 
}

예상한데로 @Inject어노테이션은 변경되지 않았고 인젝션내에서만 일부 변경이 있다.  

Named Injection


동일 타입의 여러 객체가 필요한 경우 예를 들어 SharedPreference를 용도가 다르거나 다른파일을 지정하는 등의 경우 어떻게 할것인가?
이 경우 이름을 부여할 수 있다. @Named 어노테이션을 추가하는것만으로 가능하다.

@Provides 
@Named("default") 
SharedPreferences provideDefaultSharedPrefs() { … } 

@Provides 
@Named("secret") 
SharedPreferences provideSecretSharedPrefs() { … }

주입 대상에서도 동일하게..

@Inject @Named("default") SharedPreferences mDefaultSharedPrefs; @Inject @Named("secret") SharedPreferences mSecretSharedPrefs;


Lazy Injection

성능을 고려하면 지연된 주입이 반드시 필요하다 모든 의존성을 앱실행 초기에 하면 앱이 늦게 시작될테니까. 이를 위해 지연된 주입을 지 원한다.

@Inject Lazy mLazySharedPrefs; 
void onSaveBtnClicked() { 
    mLazySharedPrefs.get()
                .edit().putString("status", "lazy...")
                .apply(); 
}

위와 같이 정의 두면 호출전까지 주입이 되지 않는다. 이 후에는 주입된 상태를 유지한다.

Provider Injection

팩토리 패턴이 가능하다. 객체를 주입하지 않고 여러 인스턴스를 만들어야 하는 경우... 이 경우 Provider가 가능하다.

@Inject 
Provider mEntryProvider; 
Entry entry1 = mEntryProvider.get(); 
Entry entry2 = mEntryProvider.get();

프로바이더가 Entry객체의 두가지 인스턴스를 만든다. 인스턴스가 모듈에서 어떠게 생성될지는 알아서...

짜증나게 하는 지점!

inject() 메서드는 강력한 타입체크를 수행한다. 이는 디버깅에 유리하지만 베이스클래스로부터 주입하는 경우 복잡하게 한다.
직관적으로 베이스클래스를 대상으로 하는 inject()메서드를 만들것이다 하지만 이는 서브클래스에 대해서는 동작하지 않는다.

해결책은 멀까? 

방법#1 은 베이스클래스에 abstract 메서드를 정의하는것이다. 

@Override 
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState); 
    injectComponent(((DemoApplication) getApplication())
                .getComponent()); 

protected void injectComponent(ApplicationComponent component);

그리고 서브클래스에서 구현한다.

@Override
protected void injectComponent(ApplicationComponent component) { 
    component.inject(this); 
}

방법#2 는 리플랙션을 사용하는것이다. 이는 당신이 다루고자 하는 타입에 해 당하는 inject()메서드를 찾는것으로 귀결된다.

먼저 당신이 정의한 콤포넌트의 모든 메서드들을 타입별로 캐시한다.

// Keep the returned cache in some helper. 
Map<Class, Method> buildCache() { 
    Map<Class, Method> cache = new HashMap<>(); 
    for (Method m : ApplicationComponent.class.getDeclaredMethods()) { 
        Class[] types = m.getParameterTypes(); 
        if (types.length == 1) { 
            cache.put(types[0], m); 
        } 
    } 
    return cache; 
}

그리고 주입시에 getClass()로 캐시로부터 꺼내고 invoke를 호출한다.

// Use for injecting targets of any type. void inject(ApplicationComponent component, Object target) { 
    Method m = cache.get(target.getClass()); 
    if (m != null) { 
        m.invoke(component, target); 
    } 
}

기본클래스에서 모든 설정을 숨기거나 이것을 수행하는 코드를 다루는 누군가에게는 유용할것이다.

짜증2 는 콤포는트 구현이 재빌드를 요구하고 클래스가 사라질때는 컴파일에러가 발생한다는 것이다. 심간한 불편함은 아니지만 프로젝트 구성 초기에는 좀 귀찮을 수 있다.

원문 : https://blog.gouline.net/dagger-2-even-sharper-less-square-b52101863542

 

Dagger 2: Even Sharper, Less Square

It was only a matter of time before version 2.0 of the well-known dependency injection library Dagger hit production and that seemed like…

blog.gouline.net

한글로 된 잘 정리된 문서

https://medium.com/@jason_kim/tasting-dagger-2-on-android-%EB%B2%88%EC%97%AD-632e727a7998

Posted by 삼스

댓글을 달아 주세요

  1. 코드제다이

    정리가 정말 잘되어 있네요 감사합니다 많이 배우고 갑니다 ㅎㅎ

    2020.01.10 10:30 [ ADDR : EDIT/ DEL : REPLY ]

Android2017. 6. 8. 13:49


https://android-developers.googleblog.com/2017/05/android-instant-apps-is-open-to-all.html


몇몇 선택된 개발자들에게만 허용되었던 안드로이드 인스탄트앱개발이 드디어 모든 개발자들에게 오픈되었다.


몇몇 선택된 개발자들에게만 허용되었던 안드로이드 인스탄트앱개발이 드디어 모든 개발자들에게 오픈되었다.


올초부터 안드로이드 인스탄트앱을 테스트하기 시작했다. 설치없이 실행가능한 앱이다. 우리 놀라운 개발자커뮤니티에 감사한다. 그들은 수많은 피드백을 우리에게 주었다. 그로 인해 end-to-end 제품경험을 개선하는데 큰 도움이 되었다.


오늘 우리는 모든 안드로이드 개발자들에게 오픈한다. 누구든 빌드하고 배포할 수 있다. 이미 50여개이상의 새로운 경험을 하는것이 가능하다. HotPads, Jet, 뉴욕타임즈, Vimeo그리고 One Football등이다. 이들은 아주 짧은 기간동안 서비스되고 있지만 아주 긍정적인 결과를 보여준다. 예를 들어 Jet과 HotPads는 두자리수의 주문이 증가했다.


초기파트너들로부터의 피드백은 오늘 제공하게 되는 개발툴을 직접 형성했다. 


인스탄트앱을 개발하려면 먼저 developer.android.com에 들어가서 Android Studio 3.0 preview와 Android Instant Apps SDK를 다운로드하라. 계속해서 단일 코드배이스를 사용하게 될것이다. Android Studio는 필요에 따라 기능을 다운로드 할 수 있도록 앱을 모듈화하는 데 필요한 도구를 제공합니다. 모든 앱들이 다르지만 우리는 초기파트너들과 최종 툴로 인스탄트앱을 개발하는데 보통 4~6주정도의 시간이 소요되는것을 보았다.


앱을 한번 개발해 놓으면 Play Console는 인스탄트앱의 배포에 대한 지원을 제공한다. 당신은 그저 설치가능한 APK와 함께 인스탄트앱 APK들을 업로드하면 된다.


40개국이상의 최신 안드로이드 디바이스에서 계속 인스탄트앱이 증가하고 있다. 그리고 Android O에서 인스탄트앱을 위한 더 향상퇸 런타임 샌드박스, 앱용량 감소를 위한 라이브러리의 공유, 런처통합 지원을 구축했다.


더 알고 싶으면 g.co/instantApps를 방문해라. 이미 "Introduction to Android Instant Apps" 세션을 올려두었고 Google I/O Youtube channel에서도 시청할 수 있다.


Posted by 삼스

댓글을 달아 주세요

Android/Wear2015. 8. 24. 16:43


안드로이드 웨어는 HTTP통신 같은 인터넷 억세스를 지원하지 않는다고 한다. 이에 어떻게 데이터 전송을 지원하는지 알아보기 위해 아래 문서를 정리해 보았다.  실제로 이 API를 wrapper하여 http get을 지원하는 lib를 만들어서 공개한 개발자도 있다.

좀더 정확히 얘기 하면 Bluetooth로 연결이 되지 않은 상태에서 wifi에 연결이 되어 있다면 인터넷 억세스가 다이렉트로 가능하다. 하지만 bluetooth가 연결이 되는 순간 먹통이 된단다. 동시에는 안된다는데... 왜 안될까??? 단말과 워치간의 데이터 동기화를 위해서는 이 때는 Data Layer API로 bluetooth를 통해서 전송하는 방법을 사용해야 한다고 한다. 이건 맞다고 보는데 이 때 wifi가 진짜 안될까????? 워치가 없으니 확인할 방법은 없고.. 궁금하긴 하다. 워치 구매하면 제일먼저 해야할 일이다.


http://developer.android.com/training/wearables/data-layer/index.html


Data Layer API for Wearable은 Google Play Service의 일부로 폰과 웨어러블간의 통신채널을 제공한다.

데이터오브젝트의 셋을 제공하는데 전송 및 동기화 그리고 관련 콜백리스너를 제공한다.


Data Items

  DataItem한개는 단발과 웨어러블간에 자동으로 동기되는 데이터 스토리지를 제공한다.


Messages

  MessageApi클래스는 메시지들을 전송할 수 있으며 RPC에 기반하여 웨버러블에서 단말의 미디어플레이어를 제어한다거나 단말에서 웨어러블에 인텐트를 시작하거나 할 수 있다.

  Message는 단방향 및 양방향 통신을 모두 제공한다.

  단말과 웨어러블이 연결되면 메세지를 전달하기 위해 시스템은 큐잉하고 성공코드를 반환한다. 디바이스가 연결이 되지 않으면 에러를 반환한다. 


Asset

  Asset객체는 이미지 같은 바이너리데이터를 전송하기 위한 객체이다. Data item에 asset을 첨부하면 시스템은 자동으로 잘 전송해준다. 


WearableListenerService(for services)

  WearableListenerService를 확장하여 서비스에서 중요한 이벤트를 처리할 수 있다. 시스템은 lifecycle을 관리하고, data item이나 message를 전송해야 하면 서비스에 바인딩하며, 서비스가 더이상 필요없으면 언바인딩한다.


DataListener(for foreground activities)

  액티비티에서 DataListener를 구현하여 액티비티가 포그라운드로 진입히 중요한 이벤트를 처리할 수 있다. WearableListenerService대신에 사용하면 앱이 사용중에만 변경을 감지할 수 있다.


Channel

  ChannelApi클래스를 사용하여 큰 data item들을 전송할 수 있다. 음악이나 동여상파일들을 단말에서 웨어러블에 전송이 가능하다. ChannelApi는 다음과 같은 잇점이 있다.

  • 하나이상의 단말간에 대용량 데이터 파일을 전송한다(DataItem에 Asset으로 자동동기화를 하지 않고 가능). 디스크용량을 절약이 가능하다. DataApi클래스의 경우 동기화하기 전에 Asset을 복사한 후 수행하기 때문에 디스크용량 절약에 불리하다.
  • MessageApi 클래스를 사용하여 아주 큰사이즈를 안정적으로 전송이 가능하다.
  • network server나 micorophone같은 스트림데이터를 전송할 수 있다.


주의) 단말과 웨어러블간의 통신을 위해서 설계가 된 API이기 때문에 두 단말간에 셋업해야 하는 API가 있다. 예를 들어 low-level 소켓통신을 시도해서는 안된다.


안드로이드 웨어는 여러개의 디바이스와 동기화를 지원한다. 한단말에서 노트를 편집하면 연결된 모든 디바이스에 동기화가 된다. 동기화를 위해 구글 서비스에 클라우드 노드가 생성되고 이 노드를 통해서 동기화가 된단다.



Posted by 삼스

댓글을 달아 주세요

Android2015. 5. 29. 11:21


사내에서 공통으로 작성된 라이브러리들을 안드로이드 스튜디오에서 임포트하여 사용하고자 하는 경우가 있을 것이다. 이 경우에 대한 가이드이다.

nexus repository가 구축되어 있다고 가정한다.

절차는 다음과 같다.

1. 라이브러리 프로젝트에서 라이브러리를 사내 메이븐레포지트리에 등록한다.

uploadArchives {

    repositories {

        apply plugin: 'maven'

        mavenDeployer {

            repository(url: "http://localhost:8000/nexus/content/repositories/snapshots") {

                authentication(userName: "userid", password:"userpassword")

            }

            pom.version = "1.0-SNAPSHOT"

            pom.artifactId = "mylib"

            pom.groupId = "com.t5online"

        }

    }

} 


2. 라이브러리를 사용할 프로젝트에서 사내 레포지트리를 추가한다.


buildscript {

    repositories {

        jcenter()

        maven {

            url "http://localhost:8000/nexus/content/groups/public"

            credentials {

                username 'userid'

                password 'userpassword'

            }

        }

    }

    dependencies {

        classpath 'com.android.tools.build:gradle:1.1.0'

    }

}

allprojects {

    repositories {

        jcenter()

        maven {

            url "http://localhost:8000/nexus/content/groups/public"

        }

    }


3. 라이브러리를 사용할 프로젝트에서 등록한 라이브러리의 디펜던시를 추가한다.

dependencies {

    compile fileTree(dir: 'libs', include: ['*.jar'])

    compile 'com.android.support:appcompat-v7:22.0.0'

    compile 'com.t5online:mylib:1.0-SNAPSHOT@aar'


위와 같이 진행하면 내부적으로 관리되는 메이븐 저장소의 라이브러리를 등록하고 다른 프로젝트에서 스크립트 수정만으로 라이브러리 디펜던시를 해결할 수 있다.

안드로이드 스튜디오에서 다른 라이브러리를 모듈로 임포트를 하면 소스까지 프로젝트로 추가되어 버리는 바람에 라이브러리 수정시 원에 위치의 소스가 관리가 안되는 문제가 있는데 이렇게 하면 원래의 라이브러리는 그 위치에 두고 관리가 되기 때문에 편리한것 같다. 다만 라이브러리 디버깅시가 문제인데 이는 라이브러리를 제작하는 측에서 알아서 지원해주어야 할 문제인 걸로...


* aar은 Android Stdio가 만들어내는 라이브러리형식인데 기존의 ADT에서 생성하는 jar과 다른 점은 resource파일들을 함께 포함한다는것이다. 기존에 jar로 만든 라이브러리가 참조하는 resource가 있는 경우 배포시 jar과 함께 리소스파일을 배포했던 불편함을 해소할 수 있다.




Posted by 삼스

댓글을 달아 주세요

  1. madzzang

    좋은 정보 감사합니다. 예전부터 nexus와 androidstuiod를 활용한 프로젝트 구축이 궁금했었는데 한방에 해결이 되었네요.

    2015.12.09 13:39 [ ADDR : EDIT/ DEL : REPLY ]