कई ऐप्लिकेशन, बिल्ड के अलग-अलग वैरिएंट में अलग-अलग तरह के व्यवहार जोड़ने के लिए, Hilt का इस्तेमाल करते हैं. यह खास तौर पर तब मददगार हो सकता है, जब आपके ऐप्लिकेशन को माइक्रोबेंचमार्क के तौर पर मार्क किया जाता है, क्योंकि यह ऐसे कॉम्पोनेंट को बंद कर दिया जाता है जिससे नतीजों पर असर पड़ सकता है. उदाहरण के लिए, निम्न कोड स्निपेट एक रिपॉज़िटरी दिखाता है, जो नामों की सूची फ़ेच और क्रम से लगाता है:
Kotlin
class PeopleRepository @Inject constructor( @Kotlin private val dataSource: NetworkDataSource, @Dispatcher(DispatcherEnum.IO) private val dispatcher: CoroutineDispatcher ) { private val _peopleLiveData = MutableLiveData<List<Person>>() val peopleLiveData: LiveData<List<Person>> get() = _peopleLiveData suspend fun update() { withContext(dispatcher) { _peopleLiveData.postValue( dataSource.getPeople() .sortedWith(compareBy({ it.lastName }, { it.firstName })) ) } } }}
Java
public class PeopleRepository { private final MutableLiveData<List<Person>> peopleLiveData = new MutableLiveData<>(); private final NetworkDataSource dataSource; public LiveData<List<Person>> getPeopleLiveData() { return peopleLiveData; } @Inject public PeopleRepository(NetworkDataSource dataSource) { this.dataSource = dataSource; } private final Comparator<Person> comparator = Comparator.comparing(Person::getLastName) .thenComparing(Person::getFirstName); public void update() { Runnable task = new Runnable() { @Override public void run() { peopleLiveData.postValue( dataSource.getPeople() .stream() .sorted(comparator) .collect(Collectors.toList()) ); } }; new Thread(task).start(); } }
अगर मानदंड के दौरान नेटवर्क कॉल शामिल किया जाता है, तो नकली नेटवर्क कॉल लागू करें ताकि आपको ज़्यादा सटीक नतीजे मिल सकें.
मानदंड की वजह से मुश्किल होने पर रीयल नेटवर्क कॉल शामिल करना मानदंड के नतीजे. नेटवर्क कॉल कई बाहरी कारकों से प्रभावित हो सकते हैं और उनकी अवधि बेंचमार्क को चलाने की दोहराने की प्रक्रिया के बीच अलग-अलग हो सकती है. कॉन्टेंट बनाने नेटवर्क कॉल की अवधि, क्रम में लगाने से ज़्यादा समय ले सकती है.
Hilt का इस्तेमाल करके नकली नेटवर्क कॉल लागू करना
dataSource.getPeople() को किया गया कॉल, जैसा कि पिछले उदाहरण में दिखाया गया है,
में नेटवर्क कॉल शामिल है. हालांकि, NetworkDataSource इंस्टेंस इंजेक्ट किया गया है
Hilt के ज़रिए पूरा किया जाता है. साथ ही, इसकी जगह नीचे दिए गए नकली लागू करने के तरीके इस्तेमाल किए जा सकते हैं
मानदंड:
Kotlin
class FakeNetworkDataSource @Inject constructor( private val people: List<Person> ) : NetworkDataSource { override fun getPeople(): List<Person> = people }
Java
public class FakeNetworkDataSource implements NetworkDataSource{ private List<Person> people; @Inject public FakeNetworkDataSource(List<Person> people) { this.people = people; } @Override public List<Person> getPeople() { return people; } }
यह नकली नेटवर्क कॉल इस तरह से डिज़ाइन किया गया है कि आप कॉल करते समय तुरंत चल सकें
getPeople() तरीका. Hilt को इसे इंजेक्ट करने के लिए, ये काम करने होंगे:
कंपनी का इस्तेमाल किया जाता है:
Kotlin
@Module @InstallIn(SingletonComponent::class) object FakekNetworkModule { @Provides @Kotlin fun provideNetworkDataSource(@ApplicationContext context: Context): NetworkDataSource { val data = context.assets.open("fakedata.json").use { inputStream -> val bytes = ByteArray(inputStream.available()) inputStream.read(bytes) val gson = Gson() val type: Type = object : TypeToken<List<Person>>() {}.type gson.fromJson<List<Person>>(String(bytes), type) } return FakeNetworkDataSource(data) } }
Java
@Module @InstallIn(SingletonComponent.class) public class FakeNetworkModule { @Provides @Java NetworkDataSource provideNetworkDataSource( @ApplicationContext Context context ) { List<Person> data = new ArrayList<>(); try (InputStream inputStream = context.getAssets().open("fakedata.json")) { int size = inputStream.available(); byte[] bytes = new byte[size]; if (inputStream.read(bytes) == size) { Gson gson = new Gson(); Type type = new TypeToken<ArrayList<Person>>() { }.getType(); data = gson.fromJson(new String(bytes), type); } } catch (IOException e) { // Do something } return new FakeNetworkDataSource(data); } }
यह डेटा, उन ऐसेट से लोड किया जाता है जो संभावित रूप से वैरिएबल की लंबाई वाले I/O कॉल का इस्तेमाल करते हैं.
हालांकि, यह प्रोसेस शुरू करने के दौरान किया जाता है. इससे कोई गड़बड़ी नहीं होगी
जब मानदंड के दौरान getPeople() को कॉल किया जाता है.
कुछ ऐप्लिकेशन, पहले से ही किसी भी बैकएंड डिपेंडेंसी को हटाने के लिए डीबग बिल्ड का इस्तेमाल करते हैं. हालांकि, आपको एक ऐसे बिल्ड पर बेंचमार्क किया जाना चाहिए, जो रिलीज़ बिल्ड के समान हो किया जा सकता है. इस दस्तावेज़ का बाकी हिस्सा, मल्टी-मॉड्यूल और मल्टी-वैरिएंट स्ट्रक्चर का इस्तेमाल करता है जैसा कि पूरे प्रोजेक्ट का सेटअप में बताया गया है.
यहां तीन मॉड्यूल होते हैं:
benchmarkable: बेंचमार्क के लिए कोड शामिल है.benchmark: इसमें बेंचमार्क कोड शामिल होता है.app: बाकी के ऐप्लिकेशन कोड में शामिल है.
पिछले हर मॉड्यूल में, benchmark नाम का बिल्ड वैरिएंट होता है. साथ ही, इसका नाम भी होता है:
debug और release के सामान्य वैरिएंट.
मानदंड मॉड्यूल कॉन्फ़िगर करना
नकली नेटवर्क कॉल का कोड, इसके debug सोर्स सेट में है
benchmarkable मॉड्यूल और पूरा नेटवर्क लागू करने की प्रोसेस release में है
स्रोत सेट जैसा है. एसेट फ़ाइल में, डेटा से मिला डेटा
नकली लागू करने की प्रोसेस, debug सोर्स सेट में है, ताकि किसी भी APK की रुकावट से बचा जा सके
release बिल्ड. benchmark वैरिएंट, release और इनके आधार पर होना चाहिए
debug स्रोत सेट का उपयोग करें. benchmark वैरिएंट के लिए बिल्ड कॉन्फ़िगरेशन
जो benchmarkable मॉड्यूल में लागू है उसका इस्तेमाल, इस तरह किया गया है:
Kotlin
android { ... buildTypes { release { isMinifyEnabled = false proguardFiles( getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro" ) } create("benchmark") { initWith(getByName("release")) } } ... sourceSets { getByName("benchmark") { java.setSrcDirs(listOf("src/debug/java")) assets.setSrcDirs(listOf("src/debug/assets")) } } }
ग्रूवी
android { ... buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' ) } benchmark { initWith release } } ... sourceSets { benchmark { java.setSrcDirs ['src/debug/java'] assets.setSrcDirs(listOf ['src/debug/assets'] } } }
benchmark मॉड्यूल में, कस्टम टेस्ट रनर जोड़ें, जो Application बनाता है
नीचे दिए गए निर्देशों के मुताबिक Hilt के साथ काम करने वाले टेस्ट करें:
Kotlin
class HiltBenchmarkRunner : AndroidBenchmarkRunner() { override fun newApplication( cl: ClassLoader?, className: String?, context: Context? ): Application { return super.newApplication(cl, HiltTestApplication::class.java.name, context) } }
Java
public class JavaHiltBenchmarkRunner extends AndroidBenchmarkRunner { @Override public Application newApplication( ClassLoader cl, String className, Context context ) throws InstantiationException, IllegalAccessException, ClassNotFoundException { return super.newApplication(cl, HiltTestApplication.class.getName(), context); } }
इससे Application ऑब्जेक्ट, जो जांच की जाती है वह
HiltTestApplication क्लास. बिल्ड में ये बदलाव करें
कॉन्फ़िगरेशन:
Kotlin
plugins { alias(libs.plugins.android.library) alias(libs.plugins.benchmark) alias(libs.plugins.jetbrains.kotlin.android) alias(libs.plugins.kapt) alias(libs.plugins.hilt) } android { namespace = "com.example.hiltmicrobenchmark.benchmark" compileSdk = 34 defaultConfig { minSdk = 24 testInstrumentationRunner = "com.example.hiltbenchmark.HiltBenchmarkRunner" } testBuildType = "benchmark" buildTypes { debug { // Since isDebuggable can't be modified by Gradle for library modules, // it must be done in a manifest. See src/androidTest/AndroidManifest.xml. isMinifyEnabled = true proguardFiles( getDefaultProguardFile("proguard-android-optimize.txt"), "benchmark-proguard-rules.pro" ) } create("benchmark") { initWith(getByName("debug")) } } } dependencies { androidTestImplementation(libs.bundles.hilt) androidTestImplementation(project(":benchmarkable")) implementation(libs.androidx.runner) androidTestImplementation(libs.androidx.junit) androidTestImplementation(libs.junit) implementation(libs.androidx.benchmark) implementation(libs.google.dagger.hiltTesting) kaptAndroidTest(libs.google.dagger.hiltCompiler) androidTestAnnotationProcessor(libs.google.dagger.hiltCompiler) }
ग्रूवी
plugins { alias libs.plugins.android.library alias libs.plugins.benchmark alias libs.plugins.jetbrains.kotlin.android alias libs.plugins.kapt alias libs.plugins.hilt } android { namespace = 'com.example.hiltmicrobenchmark.benchmark' compileSdk = 34 defaultConfig { minSdk = 24 testInstrumentationRunner 'com.example.hiltbenchmark.HiltBenchmarkRunner' } testBuildType "benchmark" buildTypes { debug { // Since isDebuggable can't be modified by Gradle for library modules, // it must be done in a manifest. See src/androidTest/AndroidManifest.xml. minifyEnabled true proguardFiles( getDefaultProguardFile('proguard-android-optimize.txt'), 'benchmark-proguard-rules.pro' ) } benchmark { initWith debug" } } } dependencies { androidTestImplementation libs.bundles.hilt androidTestImplementation project(':benchmarkable') implementation libs.androidx.runner androidTestImplementation libs.androidx.junit androidTestImplementation libs.junit implementation libs.androidx.benchmark implementation libs.google.dagger.hiltTesting kaptAndroidTest libs.google.dagger.hiltCompiler androidTestAnnotationProcessor libs.google.dagger.hiltCompiler }
पहले दिए गए उदाहरण में ये काम किए गए हैं:
- बिल्ड में ज़रूरी Gradle प्लग इन लागू करता है.
- इससे पता चलता है कि कस्टम टेस्ट रनर का इस्तेमाल, टेस्ट चलाने के लिए किया जाता है.
- इससे पता चलता है कि
benchmarkवैरिएंट, इस मॉड्यूल के लिए टेस्ट टाइप है. benchmarkवैरिएंट जोड़ता है.- ज़रूरी डिपेंडेंसी जोड़ता है.
आपको testBuildType में बदलाव करना होगा, ताकि यह पक्का किया जा सके कि Gradle
connectedBenchmarkAndroidTest टास्क, जो मानदंड करता है.
माइक्रोबैंचमार्क बनाना
मानदंड इस तरह लागू किया जाता है:
Kotlin
@RunWith(AndroidJUnit4::class) @HiltAndroidTest class PeopleRepositoryBenchmark { @get:Rule val benchmarkRule = BenchmarkRule() @get:Rule val hiltRule = HiltAndroidRule(this) private val latch = CountdownLatch(1) @Inject lateinit var peopleRepository: PeopleRepository @Before fun setup() { hiltRule.inject() } @Test fun benchmarkSort() { benchmarkRule.measureRepeated { runBlocking { benchmarkRule.getStart().pauseTiming() withContext(Dispatchers.Main.immediate) { peopleRepository.peopleLiveData.observeForever(observer) } benchmarkRule.getStart().resumeTiming() peopleRepository.update() latch.await() assert(peopleRepository.peopleLiveData.value?.isNotEmpty() ?: false) } } } private val observer: Observer<List<Person>> = object : Observer<List<Person>> { override fun onChanged(people: List<Person>?) { peopleRepository.peopleLiveData.removeObserver(this) latch.countDown() } } }
Java
@RunWith(AndroidJUnit4.class) @HiltAndroidTest public class PeopleRepositoryBenchmark { @Rule public BenchmarkRule benchmarkRule = new BenchmarkRule(); @Rule public HiltAndroidRule hiltRule = new HiltAndroidRule(this); private CountdownLatch latch = new CountdownLatch(1); @Inject JavaPeopleRepository peopleRepository; @Before public void setup() { hiltRule.inject(); } @Test public void benchmarkSort() { BenchmarkRuleKt.measureRepeated(benchmarkRule, (Function1<BenchmarkRule.Scope, Unit>) scope -> { benchmarkRule.getState().pauseTiming(); new Handler(Looper.getMainLooper()).post(() -> { awaitValue(peopleRepository.getPeopleLiveData()); }); benchmarkRule.getState().resumeTiming(); peopleRepository.update(); try { latch.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } assert (!peopleRepository.getPeopleLiveData().getValue().isEmpty()); return Unit.INSTANCE; }); } private <T> void awaitValue(LiveData<T> liveData) { Observer<T> observer = new Observer<T>() { @Override public void onChanged(T t) { liveData.removeObserver(this); latch.countDown(); } }; liveData.observeForever(observer); return; } }
पहले का उदाहरण, मानदंड और Hilt, दोनों के लिए नियम बनाता है.
benchmarkRule, बेंचमार्क के समय के हिसाब से काम करता है. hiltRule यह काम करता है:
बेंचमार्क टेस्ट क्लास पर डिपेंडेंसी इंजेक्शन. आपको
फ़ंक्शन लागू करने के लिए, @Before फ़ंक्शन में Hilt नियम का inject() तरीका
इंजेक्शन लगाना.
बेंचमार्क अपने-आप समय को रोक देता है, जबकि LiveData ऑब्ज़र्वर होता है
रजिस्टर किया गया. इसके बाद, लैच की मदद से LiveData के अपडेट होने तक इंतज़ार किया जाता है
फ़िनिशिंग. क्योंकि विज्ञापनों को कब-कब क्रम में लगाया जाता है
peopleRepository.update() को कॉल किया जाता है और जब LiveData को कोई अपडेट मिलता है,
क्रम में लगने की अवधि, मानदंड समय में शामिल होती है.
माइक्रोबेंचमार्क चलाएं
./gradlew :benchmark:connectedBenchmarkAndroidTest के साथ मानदंड चलाएं
करने के लिए बेंचमार्क की जांच की जा सकती है.
लॉगकैट:
PeopleRepositoryBenchmark.log[Metric (timeNs) results: median 613408.3952380952, min 451949.30476190476, max 1412143.5142857144, standardDeviation: 273221.2328680522...
पहले दिए गए उदाहरण में बताया गया है कि चलने के लिए 0.6 मि॰से॰ और 1.4 मि॰से॰ के बीच का मानदंड नतीजा 1,000 आइटम की सूची पर क्रम से लगाने वाला एल्गोरिदम. हालांकि, यदि आप मानदंड में नेटवर्क कॉल जोड़ें, तो बार-बार दोहराने की संख्या के बीच का अंतर ज़्यादा होता है इसलिए, क्रम से लगाने की सुविधा को लागू होने में ज़्यादा समय लगता है. इसलिए, नेटवर्क कॉल से क्रम में लगाया जा रहा है.
कोड को किसी भी समय रीफ़ैक्टर किया जा सकता है, ताकि नतीजों को आसानी से क्रम से लगाया जा सके अलग, लेकिन अगर आप पहले से Hilt का इस्तेमाल कर रहे हैं, तो आप इसका इस्तेमाल नकली चीज़ें इंजेक्ट करने के लिए कर सकते हैं इसके बजाय, मानदंड का इस्तेमाल करें.