<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Nikita Grishko on Medium]]></title>
        <description><![CDATA[Stories by Nikita Grishko on Medium]]></description>
        <link>https://medium.com/@grishko188?source=rss-c2a78d77f2ac------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*GXMl3GegBAeXYHhQbc325Q.jpeg</url>
            <title>Stories by Nikita Grishko on Medium</title>
            <link>https://medium.com/@grishko188?source=rss-c2a78d77f2ac------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 15:58:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@grishko188/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Exploring the benefits of using Hilt for Android testing]]></title>
            <link>https://medium.com/@grishko188/exploring-the-benefits-of-using-hilt-for-android-testing-edc2358aae2a?source=rss-c2a78d77f2ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/edc2358aae2a</guid>
            <category><![CDATA[dependency-injection]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[android-hilt]]></category>
            <category><![CDATA[robolectric]]></category>
            <dc:creator><![CDATA[Nikita Grishko]]></dc:creator>
            <pubDate>Fri, 24 Feb 2023 08:39:32 GMT</pubDate>
            <atom:updated>2023-02-24T08:39:32.697Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_2RR6DUhGe_2y10WqTofAw.png" /></figure><p>Testing is a crucial part of software development, and Android is no exception. Therefore, I decided that another article on tests with more practical examples would not hurt =) A small spoiler — as a practical exercise, we will test the data source that uses Jetpack DataStore. So this article will be kind of 2 in 1.</p><p>In this article, we will delve into topic of testing with Hilt. Hilt is a dependency injection library for Android that reduces the boilerplate of doing manual dependency injection in your project. <strong>Hilt is a recommended DI framework for Android development</strong>. But keep in mind that Hilt isn’t necessary for unit tests, since when testing a class that uses constructor injection, you don’t need to use Hilt to instantiate that class. Instead, you can directly call a class constructor by passing in fake or mock dependencies, just as you would if the constructor weren’t annotated. However if you are writing integration or functional tests where subject under test have more complex dependencies — Hilt will be very helpful and can save you a huge amount of time.</p><p>So, let’s start making life easier for ourselves)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ff5TnV0qm7QqGYHyfKETqQ.png" /><figcaption>Photo by Clemens van Lay on Unsplash</figcaption></figure><h3>Instrumented vs local tests.</h3><p>We first need to decide where our tests will run, as this will affect our dependencies and overall configuration. And for that we need to understand the difference between local and instrumented tests. So in accordance with <a href="https://developer.android.com/training/testing/fundamentals#instrumented-vs-local">official documentation,</a> we have:</p><ul><li>Instrumented tests that run on an Android device, either physical or emulated. Instrumented tests are usually UI tests, launching an app and then interacting with it. Instrumented tests are also applicable when your code is dependent on Android framework, for example you want to test your WorkManager, etc.</li><li>Local tests, on the other hand, execute on your development machine or a server, so they’re also called host-side tests. They’re usually small and fast, isolating the subject under test from the rest of the app.</li></ul><p>In most cases, people refer to local tests as “unit tests,” but I will use the term from the official documentation since it makes more sense. Hence, we will use the terms <strong>“local”</strong> and <strong>“instrumental”</strong> to refer to where the test is executed, and <strong>“unit”</strong>, <strong>“integration”</strong>, <strong>“UI”</strong> and<strong> “functional”</strong> to refer to the type of test.</p><p>As you can see from the screenshot below, local tests are labeled “tests” and instrumental tests are labeled “androidTests” in your project:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/510/1*IMESUFHtst52XhaYY2nA3Q.png" /></figure><p>At first glance, instrumented tests are our default pick, as you must execute tests that use Hilt in an Application object that supports Hilt (the library provides HiltTestApplication for use in tests). The instrumented tests, however, require a physical device and they are much slower to run. To avoid such inconveniences, we can use the <a href="https://robolectric.org/">Robolectric</a> library. So I’ll show you how to set up both options.</p><h3>Instrumented test setup</h3><ol><li>Adding testing dependencies</li></ol><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ff5fe401ccad9e3444832a8153948c2a/href">https://medium.com/media/ff5fe401ccad9e3444832a8153948c2a/href</a></iframe><p>2. Set the test application in instrumented tests</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/78518844a9ddccd59da60f2ecc6beb24/href">https://medium.com/media/78518844a9ddccd59da60f2ecc6beb24/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/847d23be310c45693ef21cbd58d79c7d/href">https://medium.com/media/847d23be310c45693ef21cbd58d79c7d/href</a></iframe><h3>Local test setup with Robolectric</h3><ol><li>Adding testing dependencies</li></ol><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0f9712d6c9cc34a5a6dc35a1f7fb4264/href">https://medium.com/media/0f9712d6c9cc34a5a6dc35a1f7fb4264/href</a></iframe><p>2. Set the test application in Robolectric tests</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3237bac15fbc3b98eccc255a50553189/href">https://medium.com/media/3237bac15fbc3b98eccc255a50553189/href</a></iframe><h3>Basic features</h3><ol><li>You must annotate any test that uses Hilt with @HiltAndroidTest. This annotation is responsible for generating the Hilt components for each test.</li><li>You need to add the HiltAndroidRule to the test class. It manages the components’ state and is used to perform injection on your test.</li><li>To inject types into a test, use @Inject for field injection. To tell Hilt to populate the @Inject fields, call hiltRule.inject().</li><li>If you are using more than one test rule, you need to specify the execution order:</li></ol><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0ce7716fdc124ef9b640e03412500f66/href">https://medium.com/media/0ce7716fdc124ef9b640e03412500f66/href</a></iframe><p>Or wrap the rules together as follows:</p><pre>@get:Rule<br>var hiltRule = RuleChain.outerRule(HiltAndroidRule(this))<br>    .around(UnconfinedTestDispatcherRule())</pre><h3>Customization</h3><p><strong>Hilt has several features that you can use to customize your tests once they are ready to be used.</strong></p><p>During testing, we often use test doubles. The two most commonly used options are mock objects and fake classes. With the help of Hilt, you can easily replace the real implementation with a test double. Also, at different levels of testing, you can use different variants of doubles. Let’s see how it works</p><h4>Binding replacement</h4><p>To replace a binding, you need to replace the module that contains the binding with a test module that contains the bindings that you want to use in the test. And in order to archive this we need to create a test module annotated with @TestInstallIn.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/be2bf43892c8a7f6db3d10691f5f7bde/href">https://medium.com/media/be2bf43892c8a7f6db3d10691f5f7bde/href</a></iframe><p>Now all your classes that depend on repositories will get test implementation when injected into test classes.</p><p>But what if we want to use a specific fake implementation in only one test? Well there is an option for this as well. First you have to uninstall a Hilt module from a test using the @UninstallModules , next, you must replace the binding. Create a new module within the test class that defines the test binding.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ad3387d66a2f2fcdb1b74abfe8a0874a/href">https://medium.com/media/ad3387d66a2f2fcdb1b74abfe8a0874a/href</a></iframe><p>The binding will only be replaced for one test class.</p><p><strong>Important note: The test module should resolve the same dependencies as the production module since we are completely uninstalling the original module. Otherwise, the project will not compile. You should consider this if your module has a large number of dependencies. It may be necessary to decompose the module in this case.</strong></p><h4>Replacement of providers</h4><p>In the same way as we replacing bindings, we can implement providers replacement.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4672b560e412e5957120a63fc7196643/href">https://medium.com/media/4672b560e412e5957120a63fc7196643/href</a></iframe><h4>Binding new values</h4><p>Another way to replace bindings is to use the @BindValue annotation. Here is how it is described in the official <a href="https://developer.android.com/training/dependency-injection/hilt-testing#binding-new">documentation</a>:</p><blockquote>Use the @BindValue annotation to easily bind fields in your test into the Hilt dependency graph. Annotate a field with @BindValue and it will be bound under the declared field type with any qualifiers that are present for that field.</blockquote><p>And here’s what it looks like in practice:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ff43b16685de582c00b987420415def4/href">https://medium.com/media/ff43b16685de582c00b987420415def4/href</a></iframe><p>As you can see it is also possible to replace bindings with mocks. So let’s see how to make Hilt and Mockito work together.</p><h4>Hilt and Mockito</h4><p>In some cases, you may need to replace one or more dependencies with mocks. To generate mocks, we will use the <a href="https://site.mockito.org/">Mockito</a> library. Let’s see what it looks like with an example:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/eb2daa0b23814c35579f047a723fa22f/href">https://medium.com/media/eb2daa0b23814c35579f047a723fa22f/href</a></iframe><p>As you can see, I am not using the @BindValue annotation here because the use cases are provided by the @Inject annotated constructor. In this case, we can simply replace the @Inject annotation with the @Mock annotation. Since we are not using <strong>MockitoJUnitRunner,</strong> it is important to open mocks manually. The <strong>Mockito.validateMockitoUsage() </strong>function is optional, but recommended as it checks if mocks are being used correctly.</p><h3>Practice</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9T0NXAmRuA4PFIoZ" /><figcaption>Photo by <a href="https://unsplash.com/@christinhumephoto?utm_source=medium&amp;utm_medium=referral">Christin Hume</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Finally, after we have covered most of the important theoretical aspects, it is time for some practical examples. My main rule is that the best way to learn new material is to practice with it.</p><h4>Use case</h4><p><strong>Let’s imagine that we have the task of creating a data layer for working with a user profile.</strong></p><p>The first step is to choose where we will store the data. My choice would be <a href="https://developer.android.com/topic/libraries/architecture/datastore">Jetpack Proto DataStore </a>as it is the most up-to-date method recommended by Google. I’ll skip the Jetpack DataStore setup steps as it’s not related to the topic of this article, but if you’re interested in seeing how this library works in more detail, you can take a look <a href="https://github.com/grishko188/Points-of-interest"><strong>at my GitHub project</strong></a> where I use this library. Of course, there is <a href="https://developer.android.com/topic/libraries/architecture/datastore"><strong>official documentation</strong></a> as well as the famous <a href="https://github.com/android/nowinandroid"><strong>Now in Android</strong> </a>project where this library is also used.</p><h4>Feature implementation</h4><ol><li>Creating our user_profile.proto</li></ol><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9da7671246039dbe853c1f15ee5b1ef4/href">https://medium.com/media/9da7671246039dbe853c1f15ee5b1ef4/href</a></iframe><p>2. Creating UserProfileSerializer</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/792ec77959516164529e595ac3863b12/href">https://medium.com/media/792ec77959516164529e595ac3863b12/href</a></iframe><p>3. Now let’s create a data source that will work with out DataStore</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1028588caab42bb556f7e6cd448019fb/href">https://medium.com/media/1028588caab42bb556f7e6cd448019fb/href</a></iframe><p>4. We should not forget to define the binding for our data source</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/485a9b098479c1170a80a5646c0c98ae/href">https://medium.com/media/485a9b098479c1170a80a5646c0c98ae/href</a></iframe><p>5. And last but not least we need to implement provider for our DataStore</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/340f21a80dfe96ea1f7edd59079d3254/href">https://medium.com/media/340f21a80dfe96ea1f7edd59079d3254/href</a></iframe><p>Based on the scope of our task, we are done. But! We do not have the opportunity to test our functionality, since it is not used yet, and we are not very interested in who and how will use it. But since we want to be sure that our logic works as intended, then it’s time to write an integration test for our data source.</p><h4><strong>Test coverage</strong></h4><p>To prevent our tests from causing problems with the production file, we will use a small hack. JUnit has a class — <a href="https://junit.org/junit4/javadoc/4.12/org/junit/rules/TemporaryFolder.html">TemporaryFolder</a>. By design, this is a test rule that allows the creation of files and folders that should be deleted when the test method finishes. But we’re going to use it in a slightly unorthodox way. We are going to use this as a target folder for our DataStore file.</p><ol><li>First we are going to define module that will provide us instance of TemporaryFolder.</li></ol><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a8d335c7192489c18bda7f071a707b1c/href">https://medium.com/media/a8d335c7192489c18bda7f071a707b1c/href</a></iframe><p>2. Next step we need to provide testable version of our DataStore and we are going to provide TemporaryFolder as a dependency.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fb55651b971aafa7d4e1cd7b623f058c/href">https://medium.com/media/fb55651b971aafa7d4e1cd7b623f058c/href</a></iframe><p>3. And finally our tests</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ea734699853f392fc1019641554d152a/href">https://medium.com/media/ea734699853f392fc1019641554d152a/href</a></iframe><p>Let’s go through a few important points in this test.</p><p><strong>First</strong>, we notice that we’re injecting our ProfileDataSource in the most common way with field injection, just like we would in our production code, and that’s exactly what we’re after.<br><strong>Second</strong>, as we discussed earlier, testing with Hilt requires no maintenance because Hilt automatically generates a new set of components for each test.<br><strong>Third</strong>, since we are not using TemoraryFolder as a test rule, we also inject an instance of this class using field injection to manually call the <strong>temporaryFolder.delete()</strong> function in the <strong>@After</strong> method.</p><p>And finally we got our coveted result ;-)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/313/1*3TWLOPVlaUYU7UmqPT0Msw.png" /></figure><h3><strong>Summary</strong></h3><p>And so we discussed a fairly large amount of information in one article. Technically there are a huge number of practical examples that could be considered to better represent the topic, but then this article would turn into a book, so I decided to break it up into several articles.</p><p>As we discussed at the very beginning, the Hilt is not really necessary for testing your application, but if you succeed in setting up your testing flow using the Hilt, it can save you time and also allow you to use the closest possible production way to initialize your dependencies. , which is exactly what we want to achieve in our integration tests — maximum realism.</p><h3><strong>P.S.</strong></h3><p><em>This feature, along with many others, was implemented in my open source project. So make sure you check out the repository and </em><strong><em>thanks for reading.</em></strong></p><p><a href="https://github.com/grishko188/Points-of-interest">GitHub - grishko188/Points-of-interest: Android application: Clean Architecture with Jetpack Compose and many more.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=edc2358aae2a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android: 
Make your app a share target.]]></title>
            <link>https://proandroiddev.com/android-make-your-app-a-share-target-a4c7e81e5a50?source=rss-c2a78d77f2ac------2</link>
            <guid isPermaLink="false">https://medium.com/p/a4c7e81e5a50</guid>
            <dc:creator><![CDATA[Nikita Grishko]]></dc:creator>
            <pubDate>Thu, 26 Jan 2023 11:48:11 GMT</pubDate>
            <atom:updated>2023-01-28T08:19:54.503Z</atom:updated>
            <content:encoded><![CDATA[<h3>Make your Android app a share target. Receive simple data from other applications with Hilt and Compose</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dg-mWTqbt72kLkY1TcWdiw.png" /></figure><p><em>In order to better understand sharing functionality, let’s define its use case</em>.<em> For example, if you’re developing a social media app, you might want to provide the ability to share text or images. In fact, there are many more applications for this functionality. Almost every messenger, social network, and even simple note-taking applications use this feature.</em></p><p>For a non-compose application there is a pretty straight forward guide in the <a href="https://developer.android.com/training/sharing/receive">official Android documentation</a>, but I found out that this is not exactly the same for compose applications. So let’s go and learn how to do this step by step.</p><h3><strong>Tech stack</strong></h3><p>First, let’s discuss what technologies and libraries we will use. To keep this article simple, I’m assuming that most of you are familiar with Compose and all other modern tools. If not, I highly recommend checking them out.</p><ol><li><a href="https://developer.android.com/jetpack/compose?gclid=Cj0KCQiAw8OeBhCeARIsAGxWtUzyjF9VObuL6dW0dKxom4isYwvREzdaTFHjXl03nMZmP7XaxOEIqhUaArE1EALw_wcB&amp;gclsrc=aw.ds">Jetpack Compose</a> is our UI toolkit.</li><li><a href="https://developer.android.com/jetpack/compose/navigation">Compose Navigation</a> to navigate between composables while taking advantage of the Navigation component’s infrastructure and features.</li><li><a href="https://developer.android.com/training/dependency-injection/hilt-android">Hilt</a> is our DI framework. Here is also important to know how to integrate <a href="https://developer.android.com/jetpack/compose/libraries#hilt">Hilt with Jetpack Compose</a></li></ol><p>In this list Hilt is an optional component, but it will make your life so much easier, so I highly recommend using it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DdxeSVHYqyjJuhmR" /><figcaption>Photo by <a href="https://unsplash.com/@mjessier?utm_source=medium&amp;utm_medium=referral">Myriam Jessier</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Now it is time to write some code</h3><p>First let’s update our manifest. In order to mark our application as a share target we need to specify &lt;intent-filter&gt; section for our Activity.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/561b2ee576d740de11d6d721ec35f0d5/href">https://medium.com/media/561b2ee576d740de11d6d721ec35f0d5/href</a></iframe><p>By specifying the intent filter section for our activity, we let the system know that we are ready to process the intent with the specified parameters.</p><p>So in our case those parameters will be:</p><pre>&lt;action android:name=&quot;android.intent.action.SEND&quot; /&gt;</pre><p>This is the default action that is used to share some data.</p><pre>&lt;data android:mimeType=&quot;text/*&quot; /&gt;</pre><p>Here we let the system know that we can process any text data.</p><pre>&lt;data android:mimeType=&quot;image/*&quot; /&gt;</pre><p>And this is serving for receiving an image.</p><p>For more in depth description please read the <a href="https://developer.android.com/training/sharing/receive">official guide</a>.</p><p>If you are going to launch your application right now, and then share something — your app should appear in the <a href="https://developer.android.com/training/sharing/send#:~:text=The%20Android%20Sharesheet%20is%20primarily,of%20a%20well%2Ddefined%20task.">android share sheet.</a></p><h3>Navigation</h3><p>Now it is time to update our navigation graph, as we probably want to show a specific screen that can process shared data.</p><p>Your navigation graph should look like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ed6ec7e7848aef490eb0f9e6456a2b01/href">https://medium.com/media/ed6ec7e7848aef490eb0f9e6456a2b01/href</a></iframe><p>Pretty simple isn’t it? Just like for regular <a href="https://developer.android.com/jetpack/compose/navigation#deeplinks">deep links</a>, we specify the list of navDeepLink{}<strong> </strong>. But instead of uriPattern we are specifying action and mimeType that correspond to our intent filter in the manifest. The next question is how can i access shared data? Let’s look.</p><h3>ViewModel</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/391fde249742a7ff255d81fd816c9323/href">https://medium.com/media/391fde249742a7ff255d81fd816c9323/href</a></iframe><p>And of course let’s inject our ViewModel into Composable:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/302776045dcdc7b611d58d02c17ebb19/href">https://medium.com/media/302776045dcdc7b611d58d02c17ebb19/href</a></iframe><p>Our Intent is already available to our ViewModel via the SavedStateHandle without any additional work. To access it, we need to use key <strong>NavController.KEY_DEEP_LINK_INTENT</strong>. Hilt will do all the magic for us.</p><h3>Fetching shared data from intent</h3><p>The last step is to get the data from the intent. So let’s implement our Intent.parseSharedContent() function.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/48dc03e0d8ddf458bf1d60bcb72cedfe/href">https://medium.com/media/48dc03e0d8ddf458bf1d60bcb72cedfe/href</a></iframe><p>As you can see from this piece of code, you need to use the following method to access text data:</p><pre>val textContent:String? = getStringExtra(Intent.EXTRA_TEXT)</pre><p>And to access image data you need to use:</p><pre>val imageContent: Uri? = getParcelableExtra&lt;Parcelable&gt;(Intent.EXTRA_STREAM) as? Uri</pre><p><strong>And that is it!</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JPhBo2zQRF5L5z4BrtSV1A.png" /></figure><p><em>This feature, along with many others, was implemented in my open source project. So make sure you check out the repository and </em><strong><em>thanks for reading.</em></strong></p><p><a href="https://github.com/grishko188/Points-of-interest">GitHub - grishko188/Points-of-interest: Android application: Clean Architecture with Jetpack Compose and many more.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a4c7e81e5a50" width="1" height="1" alt=""><hr><p><a href="https://proandroiddev.com/android-make-your-app-a-share-target-a4c7e81e5a50">Android: 
Make your app a share target.</a> was originally published in <a href="https://proandroiddev.com/">ProAndroidDev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>