모듈을 사용하여 라이브러리를 만드는 방법은 무엇입니까?

Question

나는, 몇 가지 라이브러리 (코어와 모듈)를 만드는 핵심 라이브러리 모듈에서 응용 프로그램과 호출 방법에 모든 라이브러리를 추가하고 싶습니다. 모든 모듈은 선택적이어야합니다. 예를 들어, 나는 그것을보고 같이

응용 프로그램 build.gradle : 모든 모듈에서

compile('core-library:1.0@aar') 
compile('module1-library:1.0@aar') 
compile('module2-library:1.0@aar') 
compile('module3-library:1.0@aar') 

는 클래스와 같은 이름의 메소드를 정의 :

for(ModuleClass c : getAllModules()) { 
    Log.d("tag", "Result: " + c.moduleMethod1() + "/" + c.moduleMethod2(); 
} 

: 핵심 라이브러리에서

public class ModuleClass { 
    public int moduleMethod1() { 
     // Do something and return result 
     return 1; 
    } 

    public String moduleMethod2() { 
     return "Some String"; 
    } 
} 

그건 그냥 의사 코드입니다. 어떻게 구현할 것인가?

업데이트 : 코어 모듈 build.gradle는 :

apply plugin: 'com.android.library' 

android { 
    compileSdkVersion 24 
    buildToolsVersion "24.0.3" 

    defaultConfig { 
     minSdkVersion 9 
     targetSdkVersion 24 
     versionCode 1 
     versionName "1.0" 

     testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" 

     buildConfigField "String[]", "KNOWN_MODULES", "{" + 
       "\"module1\"," + 
       "\"module2\"" + 
       "}" 
    } 
    buildTypes { 
     release { 
      minifyEnabled false 
      proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' 
     } 
    } 
} 

dependencies { 
    compile fileTree(include: ['*.jar'], dir: 'libs') 
    compileOnly project(':module1') 
    compileOnly project(':module2') 
    testCompile 'junit:junit:4.12' 
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', { 
     exclude group: 'com.android.support', module: 'support-annotations' 
    }) 
} 

Answer 1

당신은 core-library에 List<Class>을 추가하는 등 뭔가를 시도 할 수 있습니다. 목록을로드하려고 할 때 조심해야하지만 할 수 있어야합니다.

먼저 moduleN-library은 compileOnly 일 필요가 있으므로 core-library과 번들로 제공되지 않습니다. 그런 다음에

당신의 core-library 안전하게 가능한 모든 모듈 클래스를 나열하는 싱글 톤을 유지한다.

package com.jbirdvegas.test; 

import java.util.HashMap; 
import java.util.Map; 

public class ModuleClassManager { 
    private static final Object LOCK = new Object(); 
    private static ModuleClassManager instance; 

    private Map<Class, Methods> moduleClasses = new HashMap<>(); 

    private ModuleClassManager() { 
     try { 
      moduleClasses.put(MayNotExist1.class, new MayNotExist1()); 
     } catch (Exception ignored) { 
     } 
     try { 
      moduleClasses.put(MayNotExist2.class, new MayNotExist2()); 
     } catch (Exception ignored) { 
     } 
     try { 
      moduleClasses.put(MayNotExist3.class, new MayNotExist3()); 
     } catch (Exception ignored) { 
     } 
    } 

    public static ModuleClassManager getInstance() { 
     if (instance == null) { 
      synchronized (LOCK) { 
       instance = new ModuleClassManager(); 
      } 
     } 
     return instance; 
    } 

    public void callMethodOnAll() { 
     moduleClasses.forEach((aClass, methods) -> methods.methodOne()); 
    } 

    // the below interface in the real world would be located 
    // in the `core-library` and the classes that implement the 
    // interface, `Methods` in this example, would exist in the 
    // module's they represent. 
    interface Methods { 
     void methodOne(); 
    } 

    class MayNotExist1 implements Methods { 
     @Override 
     public void methodOne() { 
     } 
    } 

    class MayNotExist2 implements Methods { 
     @Override 
     public void methodOne() { 
     } 
    } 

    class MayNotExist3 implements Methods { 
     @Override 
     public void methodOne() { 
     } 
    } 
} 

또는 ... OSGi를 사용하십시오. OSGi는 설정하기가 더 복잡하지만이 유스 케이스를 매우 잘 처리합니다.