<?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 Raj Gohil on Medium]]></title>
        <description><![CDATA[Stories by Raj Gohil on Medium]]></description>
        <link>https://medium.com/@rajgohil044?source=rss-1bf9bdb89775------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*El-xkDtpGmF5FJmKP1BTOw.png</url>
            <title>Stories by Raj Gohil on Medium</title>
            <link>https://medium.com/@rajgohil044?source=rss-1bf9bdb89775------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 06:24:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rajgohil044/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[How We Made All Swiggy Apps Operations AI-Native]]></title>
            <link>https://medium.com/swiggy-bytes/how-we-made-all-swiggy-apps-operations-ai-native-1343612ec228?source=rss-1bf9bdb89775------2</link>
            <guid isPermaLink="false">https://medium.com/p/1343612ec228</guid>
            <dc:creator><![CDATA[Raj Gohil]]></dc:creator>
            <pubDate>Fri, 17 Jul 2026 06:23:56 GMT</pubDate>
            <atom:updated>2026-07-17T06:23:56.571Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qUA5l62J2u06AaVLkGg1hw.png" /></figure><p>Engineering across all Swiggy Apps has always had a simple problem with a very large surface area: we ship fast, but every release, every production signal, and every operational review touches too many systems.</p><p>For a single release manager or on-call engineer, the day could start across Jira, Confluence, Bitrise, Play Console, Crashlytics, New Relic, Google Sheets, ImageKit dashboards, and Slack threads. None of these tools were wrong. Each had the data it was supposed to have. The problem was that the human had become the integration layer.</p><p>That does not scale.</p><p>Over the last few months, we have been rebuilding ways of working across all Swiggy Apps around a different idea: let engineers stay where the work is happening, and let agentic AI do the repetitive context gathering, cross-tool correlation, formatting, reminders, and first-level analysis.</p><p>The result is not one chatbot. It is an operating layer for mobile engineering. Release checklists, app vitals, New Relic observability, CDN and ingestion cost tracking, TRM follow-ups, rollout health, QA automation, and on-call analysis are now increasingly handled through AI skills, MCPs, scheduled jobs, and Slack-native agent workflows.</p><p>This is the story of what changed.</p><h3>The Problem: Operational Load Hidden In Plain Sight</h3><p>The Swiggy Apps ecosystem is not one app and one release train. It spans multiple business lines and shell apps across Android and iOS. Each team cares about stability, performance, release quality, app size, cost, experimentation safety, and user experience. Each of those has its own telemetry and review rhythm.</p><p>Before automation, a lot of high-leverage engineering time was being consumed by low-leverage work:</p><ul><li>Pulling the same vitals every morning.</li><li>Checking whether release tickets had missing QA owners or blockers.</li><li>Generating release notes and checklist summaries.</li><li>Looking up Crashlytics and Play Vitals before ramping rollout.</li><li>Mapping New Relic alerts to owning teams, widgets, banners, APIs, or configs.</li><li>Preparing TRM notes and chasing action item updates.</li><li>Explaining bandwidth or ingestion cost spikes after the bill had already moved.</li></ul><p>The team did not need another dashboard. We already had dashboards. What we needed was an assistant that could connect the dashboards, understand our workflows, and show up inside the channel where decisions were already being made.</p><h3>The Shift: From Dashboards To Agents</h3><p>We built around a few operating principles.</p><p>First, AI should work inside Slack, not as a separate destination. Engineers already coordinate releases, incidents, and TRMs in channels and threads. If the agent can read the same context, run the same checks, and post structured output there, adoption becomes natural.</p><p>Second, AI should be connected to real tools. A generic model cannot run release operations. Our workflows use domain skills and MCPs for Jira, Confluence, New Relic, Firebase, Play Vitals, Bitrise, Google Sheets, Appium, Playwright, Databricks, ImageKit, and internal mobile tooling.</p><p>Third, humans should stay in control of judgement-heavy decisions. The agent can recommend RAMP, HOLD, or ROLLBACK. It can summarize freshness of crashes, ANRs, adoption, and vitals. But rollout approval remains a human gate.</p><p>Fourth, automation must be reusable. A one-off prompt is useful once. A skill, cron, or MCP is useful every week.</p><p>That mindset changed our execution speed more than any individual tool did.</p><h3>1. Release Management From Slack</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M1-o4s6xSHBfhJkApXPFzw.png" /></figure><p>Release management was one of the clearest places to start because the workflow had a lot of repeatable structure.</p><p>We automated major RM tasks through AI agent skills for Android and iOS release readiness. A release manager can now ask for release status, bug bash readiness, blockers, unassigned tickets, missing QA owners, BL-wise grouping, release notes, or release checklist status directly from Slack.</p><p>The old flow required a release manager to open Jira, filter by fixVersion, manually group tickets, check status transitions, look at QA ownership, scan blockers, and then format an update for the team. The new flow is intent-driven:</p><blockquote>Run Android release readiness for this version.</blockquote><p>The agent pulls from Jira, groups the work, identifies gaps, and posts a structured update. It is not just a summary; it is a decision aid.</p><p>We also moved repetitive release hygiene into automation:</p><ul><li>Baseline profile updates no longer need manual PR verification in the common path.</li><li>Release checklists centralize APK size, memory leak reports, benchmark results, and other pre-release quality signals.</li><li>Release notes can be generated from the release scope.</li><li>Build creation can be triggered through the assistant.</li><li>TRM action items can be followed up through a skill and cron instead of individual manual pings.</li></ul><p>This changes the release manager’s role. The RM is no longer a person doing clerical integration across tools. The RM becomes the reviewer of an already-prepared operational picture.</p><h3>2. AI-Gated Rollouts</h3><p>The most visible release automation is rollout health.</p><p>For staged Play rollouts, the agent correlates Crashlytics, Play Vitals, and rollout adoption to recommend whether the release should ramp, hold, or roll back. This has already been used live in rollout discussions where health checks at early percentages informed the next ramp decision. One example is a 1 percent to 5 percent ramp on a release version after the assistant found no fresh fatal signal.</p><p>The important part is not that AI clicks the button. It does not. The important part is that the agent removes the manual pre-work before the decision:</p><ul><li>What is current adoption?</li><li>Are there fresh fatal crashes?</li><li>Are ANRs moving?</li><li>Are vitals within expected range?</li><li>Are there carry-over issues from earlier releases?</li><li>Does the signal justify a ramp, hold, or rollback?</li></ul><p>The final action still sits behind approval. That is the right balance. AI handles the repetitive analysis; humans retain accountability.</p><h3>3. Daily Observability Without Daily Pulls</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4JKQGhZGxchbHlVU8VGDSQ.png" /></figure><p>Observability used to be highly dependent on who remembered to check what.</p><p>Today, teams across all Swiggy Apps have moved toward recurring AI-driven observability crons that post daily updates into team channels. These cover app vitals such as crash rate, ANR rate, and startup time; UX zippiness metrics; top-of-funnel API RTT; New Relic ingestion; ImageKit CDN bandwidth; and scale-up health updates.</p><p>This sounds simple, but it changes behavior.</p><p>When vitals arrive every day in the channel, observability becomes ambient. The team does not need to wait for a TRM to rediscover a trend. If a startup metric, page load, API latency, or bandwidth number moves, the conversation can start immediately and with context.</p><p>We also invested in deeper signals. For example, warm and hot start debugging now has fragment-level information in New Relic, debug traces similar to cold start traces, and lifecycle timing breakdowns from create to resume to first draw. That means startup regressions can be traced to specific screens or fragments rather than discussed as a vague app-level number.</p><p>This is the difference between “startup is bad” and “this screen path is responsible, here is the owner, here is the metric, here is the next action.”</p><h3>4. Alert Triage With Context, Not Just Noise</h3><p>Alerts are cheap to create and expensive to interpret.</p><p>New Relic alerts used to trigger the same set of questions repeatedly: what changed, which widget or API is involved, who owns it, whether it is a real regression, and what the historical baseline says. The agentic workflow now does the first-level investigation.</p><p>For ImageKit 404 alerts, the assistant has mapped alerts down to the widget, banner ID, missing asset, and config owner. For frozen-frame alerts on collection pages, it has traced top collection IDs to Gandalf layouts, carousel widgets, banner IDs, and Lottie asset URLs. For network issues, the agent can facet signals by dimensions such as ASN and produce an investigation-ready summary.</p><p>Internally, we had already seen the same need in earlier tooling across all Swiggy Apps: New Relic alerts, crashes, and ANRs required manual context gathering across NR, code, logs, Jira, and Slack. The new MCP-backed flow reduces the alert-to-analysis loop from a manual hunt to a structured first response.</p><p>The goal is not to pretend every RCA is solved by AI. The goal is to make sure an engineer starts from the second page of debugging, not the first.</p><h3>5. Cost Tracking As An Engineering Signal</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b6ZQuLRj-ADOGBIJ8m_BIw.png" /></figure><p>Cost used to appear late in the cycle. A bandwidth or ingestion spike would show up in a bill, someone would ask why, and then engineers would reconstruct the story from dashboards and release timelines.</p><p>We changed that by treating cost as part of daily observability.</p><p>ImageKit bandwidth, storage, and video processing signals are now tracked in the same operating rhythm as vitals. New Relic ingestion is also tracked and compared so teams can catch volume changes earlier. Our in house Mobile Toolkit adds a self-serve NR cost optimisation suite with drop filters and cost tracking. The broader release platform now brings CI/CD, Play/App Store release tracking, release quality, and cost visibility into one place.</p><p>This matters because mobile cost problems often hide inside engineering details:</p><ul><li>A media transform change can increase CDN processing.</li><li>A logging or event schema change can increase New Relic ingestion.</li><li>A missing image transform can inflate bytes received.</li><li>A noisy 404 path can create both alert fatigue and bandwidth waste.</li></ul><p>When the daily report includes the why, not just the number, cost becomes actionable. The discussion moves from “the bill went up” to “this version, transform, event table, or asset path moved.”</p><p>That is a better operating model.</p><h3>6. The Long Tail: Skills For Repeated Work</h3><p>Once the team saw the pattern, the automation surface expanded quickly.</p><p>We now have or are actively using skills and MCPs for:</p><ul><li>New Relic query validation and alert investigation.</li><li>Play Vitals analysis.</li><li>Firebase and Crashlytics reports.</li><li>Weekly TRM generation.</li><li>Bitrise build and CI/CD stats.</li><li>Appium and Playwright test generation and execution.</li><li>Perfetto-based performance debugging.</li><li>Google Sheets and Docs automation.</li><li>Figma user journey mapping.</li><li>Engineering code review checks.</li><li>Specialized Swiggy mobile agents for screen exploration, DI wiring, analytics, network layer, and screen-specific code tasks.</li></ul><p>The important cultural change is that engineers are no longer waiting for a central platform team to automate every workflow. The people closest to the pain are building skills for their own repeated work, and those skills are being shared across all Swiggy Apps.</p><p>That is how automation becomes contagious.</p><h3>What Changed Operationally</h3><p>The most obvious improvement is speed. Tasks that earlier required opening several tools now finish in a Slack thread. Some internal examples show New Relic alert analysis in under a minute, UXZ or P0 metric summaries in under two minutes, and custom New Relic metric crons in minutes instead of a manual setup cycle.</p><p>But speed is only one part of the story.</p><p>The bigger change is reduction in cognitive load. Engineers no longer need to remember every dashboard, query, ownership map, release checklist field, or TRM follow-up format. The agent brings the checklist to them.</p><p>We also improved consistency. A manually written release update depends on who is writing it and how much time they have. An automated readiness check follows the same structure every time. Daily vitals reports create the same operating rhythm every morning. TRM action items no longer depend on someone remembering to chase every owner.</p><p>And finally, we improved accountability. When observability, release readiness, rollout health, and cost signals are posted in shared channels, gaps become visible early. The team can act before an issue turns into a production surprise.</p><h3>What We Learned</h3><p>The first lesson is that the best AI workflows are boring in the right way. They do not need to feel futuristic. They need to save X minutes every day, reduce one avoidable miss every release, and remove one manual chase every TRM.</p><p>The second lesson is that AI needs domain tools. A model without access to Jira, New Relic, Play Vitals, Crashlytics, Bitrise, Confluence, and internal release systems is only a writer. A model connected through skills and MCPs becomes an operator.</p><p>The third lesson is that approvals matter. For release rollouts, the safest pattern is recommendation plus human gate. The agent prepares the operational view; the owner approves the action.</p><p>The fourth lesson is that visibility creates adoption. When an automation posts a useful daily report in a channel, everyone sees the value. When a release manager asks a question in Slack and gets a structured answer in seconds, the next RM tries it too.</p><p>The fifth lesson is that small automations compound. A release checklist skill, a vitals cron, a New Relic alert analyzer, a TRM follow-up bot, and a CDN cost report may look small individually. Together, they change how a team operates.</p><h3>What Is Next</h3><p>We are still early.</p><p>The next phase is to expand AI-gated rollouts to more surfaces across all Swiggy Apps, bring more approvers and guardrails into the approval flow, extend daily observability coverage across shell apps, add per-session network data consumption tracking, and build stronger business-impact overlays for performance and reliability signals.</p><p>We also want every repeated operational workflow to have the same question attached to it:</p><blockquote>Why is a human still doing this manually?</blockquote><p>Not because humans are unimportant. The opposite. Human judgement is too valuable to spend on copying metrics, chasing owners, formatting reports, and switching tabs.</p><p>Our goal is simple: make the Swiggy Apps operations fast, visible, consistent, and AI-native. Let agents handle the mechanical load. Let engineers focus on judgement, product quality, architecture, and execution.</p><p>That is how we improve speed without losing control. That is how we reduce operational load without reducing ownership. And that is how the Swiggy Apps ecosystem is turning AI from a productivity experiment into a real operating model.</p><h3>Acknowledgements</h3><p>This shift wouldn’t have happened without a lot of people quietly doing the hard work. <a href="https://medium.com/u/adb4aa10275a">Pratik Sahu</a> ideated and built the agentic AI-driven flows that made this real, with <a href="https://medium.com/u/723d70adf627">Sambuddha Dhar</a> guiding him. <a href="https://medium.com/u/400467f4ffab">Tushar Tayal</a> put his trust in the team to experiment and take it live — and that trust is what let this move from an idea to something running in production.</p><p>And the entire Apps team — the engineers, QA partners, release managers, on-call owners, and platform contributors who kept questioning repetitive work, turned operational pain into reusable automations, and kept building more skills and workflows around it. Their ownership across releases, observability, cost, and quality is what turned AI from an experiment into how Consumer Apps actually works now.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1343612ec228" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swiggy-bytes/how-we-made-all-swiggy-apps-operations-ai-native-1343612ec228">How We Made All Swiggy Apps Operations AI-Native</a> was originally published in <a href="https://medium.com/swiggy-bytes">Swiggy Bytes — Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OK Google, lets order from Swiggy]]></title>
            <link>https://medium.com/swiggy-bytes/ok-google-lets-order-from-swiggy-90d2bd0b9c3a?source=rss-1bf9bdb89775------2</link>
            <guid isPermaLink="false">https://medium.com/p/90d2bd0b9c3a</guid>
            <category><![CDATA[voice-assistant]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[swiggy-engineering]]></category>
            <category><![CDATA[swiggy-mobile]]></category>
            <category><![CDATA[google-app-actions]]></category>
            <dc:creator><![CDATA[Raj Gohil]]></dc:creator>
            <pubDate>Tue, 11 Feb 2020 13:34:59 GMT</pubDate>
            <atom:updated>2024-03-30T09:14:36.127Z</atom:updated>
            <content:encoded><![CDATA[<h4>Google Assistant can now order your pizzas and biryanis on Swiggy, and track your orders too. Here’s how we did it…</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m987Ll_5Op0o96FFM1peBQ.png" /><figcaption>image source : <a href="https://undraw.co/">undraw.co</a></figcaption></figure><p>At Swiggy, we always want to offer our new features to the users which will help them to use our App conveniently. Given that <strong>voice</strong> is the ‘next billion thing’ which will enable a lot of Users, we wanted to introduce the features we have enabled with Google Assistant that will help Users to <strong>“Track the Order”</strong> without the need of opening App and <strong>‘search’</strong> any restaurant/dish directly on the Swiggy app via voice. So, this thought led us to integrate Google Assistant with our swiggy app and give users a new way to interact with our app.</p><p>In this post, we’ll explain how we integrated Google app actions with our app to make it functional.</p><h3><strong>What are app actions ?</strong></h3><p>App Actions help expand the reach of our Android app by letting users launch directly into specific app features from the Google Assistant. App Actions are built on top of an app’s deep links. To support App Actions, you must implement <a href="https://developer.android.com/training/app-links/deep-linking"><em>Android deep links</em></a> to your app content, allowing the Android system to invoke a specific Activity when the App Action is invoked.</p><p>App Actions are now the new trending way to display the app’s content on Google Assistant app. By enabling App Actions, users can easily launch app’s features by simply speaking to the Google Assistant. For example: users can say <strong>“Ok Google, order pizza from Swiggy”</strong>. When users invoke an App Action, the Assistant either launches a screen in the Android app or shows an embedded visual card (Android Slice) that users can interact with.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*3OHgJkmDv-8siVKrUIm-iw.gif" /><figcaption>App actions for search</figcaption></figure><p>For example, the user could say <strong>“Ok Google, order pizza from Swiggy”</strong> to launch the search screen with query as pizza on swiggy app. The user could later say <strong>“Ok Google, check my order from Swiggy?”</strong> and the Assistant would display an Android Slice showing the food’s expected arrival time and its other relevant information and a suggestion chip to optionally open the app.</p><h4>Following are the ways to access the app actions :</h4><blockquote>1. Deep linking into Android apps : App Actions can take users directly to specific content in the app by using <a href="https://developer.android.com/training/app-links/deep-linking">Android deep links</a> , which we specify using intent filters in the Android app manifest.</blockquote><blockquote>2. Users can invoke App Actions to launch <a href="https://developer.android.com/guide/slices">Android Slices</a>. This lets them perform focused tasks using UI from the app, which is presented through the assistant.</blockquote><h3><strong>What are slices ?</strong></h3><p>Slices are rich UI being displayed in the Google app itself without visiting the actual app. These can display rich, dynamic, and interactive content from the Android app within the Google Search app and later in other places like the Google Assistant. Slices can help users perform tasks faster by enabling engagement outside of the fullscreen app experience. You can build Slices as enhancements to <a href="https://developer.android.com/guide/actions"><em>App Actions</em></a>. Support for Slices is built into <a href="https://developer.android.com/jetpack"><em>Android Jetpack</em></a> and can extend all the way back to Android 4.4, reaching approximately 95% of all Android users.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M4hdu793XTIYR8JnN6C8oA.jpeg" /><figcaption>App actions to track order(slices)</figcaption></figure><p>We have used slices to show our food tracking status which comes handy when user don’t want to open the app and check the order status. He/she can trigger it via Google Assistant by saying <strong>“Ok Google, check my order from Swiggy”</strong> and relevant info will be displayed on Google search app itself.</p><h3><strong>How does it work ?</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8BuItvBCgFJD5cmAsoRK7Q.png" /><figcaption>Lets explore</figcaption></figure><ul><li>From a user’s perspective, App Actions behave like shortcuts to parts of the Android app.</li><li>When a user says something on the Google Assistant, Google extracts out the query from the said sentence. Internally, when a user’s query matches the built-in intent grammar, the Assistant extracts the query parameters into <a href="https://schema.org/"><em>schema.org</em></a> entities and generates an <a href="https://developer.android.com/training/app-links/deep-linking"><em>Android deep link</em></a> URL using the mappings we provide through the actions.xml file. Google then creates a final deep link URL by attaching the extracted parameters to take users directly to specific screen in the app without additional conversational dialog.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xn0KIL-Oo6NtnTATShKrfA.png" /><figcaption>Image source : <a href="https://developers.google.com/assistant/app/overview">Google</a></figcaption></figure><h3><strong>How we did our app’s integration with Google Assistant ?</strong></h3><h4>Following are the steps of integration :</h4><ul><li>Create <strong>actions.xml</strong> file in <strong>res/xml</strong> folder so that path will be as <strong>res/xml/actions.xml</strong>. This file contains all the actions with built-in intents supported by Google.</li><li>Slice provider is a wrapper over Android’s <a href="https://developer.android.com/guide/topics/providers/content-providers"><em>content provider</em></a><em> </em>only. So, you need to define provider in <a href="https://developer.android.com/guide/topics/manifest/manifest-intro"><em>AndroidManifest</em></a> and define <a href="https://developer.android.com/guide/topics/manifest/intent-filter-element"><em>intent filter</em></a> too.</li><li>Each action must contain a <a href="https://developers.google.com/assistant/app/intents"><em>built-in</em></a> <strong>intentName </strong>field. For example: for ordering food, intent name will be <a href="https://developers.google.com/assistant/app/reference/built-in-intents/#order-menu-item"><em>actions.intent.ORDER_MENU_ITEM</em></a>.</li><li>Each action must be defined with a fulfilment mode which can be of type <strong>deep links</strong> or <strong>slices</strong>.</li></ul><p><strong>Preferably the following two fulfilment modes are there:</strong></p><blockquote>1. “actions.fulfillment.DEEPLINK” : for direct deep links</blockquote><blockquote>2. “actions.fulfillment.SLICE” : for slices</blockquote><ul><li>Each action must contain a URL template which will be used to launch your app.</li></ul><p><strong>This URL template can be the following ones :</strong></p><blockquote>1. direct deep link to your app</blockquote><blockquote>2. URL to Slice provider</blockquote><ul><li>Note that the urlTemplate must be of the style <strong>content://{slice_provider_authority}/… </strong>and make sure that the authority matches with the one defined in <a href="https://developer.android.com/guide/topics/manifest/manifest-intro"><em>AndroidManifest</em></a><em>.</em></li><li>Parameter mapping can be provided in this URL template so that after parsing the queries Google attaches them in the URL template and generates a deep link to be handled by your app.</li></ul><p><strong>An action example :</strong></p><pre><strong>&lt;action intentName=&quot;actions.intent.ORDER_MENU_ITEM&quot;&gt;<br>    &lt;fulfillment<br>        fulfillmentMode=&quot;actions.fulfillment.DEEPLINK&quot;<br>        urlTemplate=&quot;swiggy://explore{?dish}&quot;&gt;<br>        &lt;parameter-mapping<br>            intentParameter=&quot;menuItem.name&quot;<br>            urlParameter=&quot;dish&quot; /&gt;<br>    &lt;/fulfillment&gt;<br>&lt;/action&gt;</strong></pre><p>Here, suppose if the user query is <strong>“Ok Google, order biryani from Swiggy”</strong> then Google will parse the query as ‘<strong>biryani’</strong> and map the dish param in the <strong>urlTemplate </strong>and generate the deep link as <strong>swiggy://explore?dish=biryani </strong>which will ultimately open swiggy app with specified deep link screen.</p><p>Follow <a href="https://developer.android.com/guide/slices/getting-started"><em>this</em></a> self explanatory Slice integration guide to integrate the slices. Important step to integrate slice is you have to mention fulfilment mode as <strong>fulfillmentMode=”actions.fulfillment.SLICE” </strong>while defining slice action in <strong>actions.xml</strong>. This will indicate to the user that this is a slice action.</p><h3>Google has provided a test tool for this feature called App Actions Test Tool.</h3><p>The <a href="https://plugins.jetbrains.com/plugin/12322-app-actions-test-tool/"><em>App Actions test tool</em></a> is an Android Studio plugin for developers creating App Actions. During development and testing, you use the App Actions test tool to create a preview of your App Actions in the Assistant (for your Google account). You can then test how your App Action handles various parameters prior to submitting it for deployment.</p><h4>What it does ?</h4><p>The App Actions test tool parses your <a href="https://developers.google.com/assistant/app/action-schema">actions.xml</a> file and creates a preview of your App Actions for a single Google account. These previews enable the Assistant to recognise your App Actions prior to deploying the production version of your app to the Google Play Console.</p><h4>Following are the quick points to test this feature :</h4><blockquote>1. Install <a href="https://plugins.jetbrains.com/plugin/12322-app-actions-test-tool/"><em>App Actions test tool</em></a><em> </em>plugin from in Android Studio.</blockquote><blockquote>2. You have to sign in to Android Studio(version 3.4 or higher) and Google app with the Google account which has Google Play Console access to your published app.</blockquote><blockquote>3. App package name(applicationId) should be same as your published app.</blockquote><blockquote>4. Open the Google app on your Android test device and finish the initial Assistant setup process.</blockquote><blockquote>5. Open <a href="https://plugins.jetbrains.com/plugin/12322-app-actions-test-tool/"><em>App Actions test tool</em></a><em> , c</em>lick <strong>Create Preview</strong>. Once your preview is created, the test tool window will update to display information about built-in intents found in your file <strong>actions.xml</strong>.</blockquote><blockquote>6. To update an existing preview to match your file <strong>actions.xml</strong>, click the <strong>Update Preview</strong> button in the test tool.</blockquote><h4><strong>Suggestion</strong></h4><p>App Action previews are recommended to test on physical devices. Attempts to trigger an App Action preview on a virtual device are likely to result in the message “Sorry, I couldn’t find that”.</p><h3><strong>A few important points that we learnt while integrating the app actions:</strong></h3><ul><li>If your app has multiple build types then for testing it, you have to use the same build type as on the Play Store which means the package name(applicationId) of the build type should exactly match with your play store published app’s build type.</li><li>Be careful that <strong>actions.xml</strong> shouldn’t be <strong>obfuscated</strong> in your release apk if you are using <a href="https://www.guardsquare.com/en/products/proguard"><em>proguard</em></a>.</li><li>Slices are build on top of Android’s <a href="https://developer.android.com/guide/topics/providers/content-providers"><em>content provider</em></a> only. So, <strong>SliceProvider’s</strong> <strong>onCreateSliceProvider() </strong>can be called before your application’s <strong>onCreate()</strong>. So, if you are planning to initialise something in your applications’s <strong>onCreate()</strong> and use it in SliceProvider’s <strong>onCreateSliceProvider() </strong>or<strong> onBindSlice() </strong>then you can run into problems.</li><li>If there’s a time taking network or DB call, then slices can’t wait for the response to appear. For blocking calls you can show a loading slice and when you get the response from the call you can call <strong>notifyChange()</strong> which will call <strong>onBindSlice()</strong> and then you can pass the latest fetched info to slices.</li><li>However, beware if there’s a recurring network call then it can call <strong>notifyChange() </strong>as many times as response is received which will ultimately call <strong>onBindSlice() </strong>that many times and you will fall into a loop.</li></ul><h3>Acknowledgements</h3><p>I would like to thank <a href="https://twitter.com/Sourabh96334555">Sourabh Gupta</a> for assigning me this cool feature to work on. Thanks to <a href="https://medium.com/u/2f66d0638af6">Naho Ito</a> and <a href="https://medium.com/u/55362b009039">Marcel Pintó</a> for clearing the doubts.</p><blockquote><em>I’m </em><a href="https://twitter.com/rajgohil044"><em>Raj Gohil</em></a><em> from Android team at </em><a href="https://www.swiggy.com/"><em>Swiggy</em></a><em>. If you enjoyed learning about this and want to be a part of an exciting tech culture, feel free to visit </em><a href="https://careers.swiggy.com/"><em>swiggy careers</em></a><em>, we are hiring.</em></blockquote><p>References :</p><ul><li><a href="https://developers.google.com/assistant/app/overview">App Actions overview | Google Developers</a></li><li><a href="https://codelabs.developers.google.com/codelabs/appactions/#0">Extend an Android app to the Google Assistant with App Actions</a></li><li><a href="https://material.io/design/platform-guidance/android-slices.html#">Android slices</a></li><li><a href="https://developers.google.com/assistant/app/test-tool">App Actions test tool | Google Developers</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=90d2bd0b9c3a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swiggy-bytes/ok-google-lets-order-from-swiggy-90d2bd0b9c3a">OK Google, lets order from Swiggy</a> was originally published in <a href="https://medium.com/swiggy-bytes">Swiggy Bytes — Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>