<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="androidenterprise_v1.html">Google Play EMM API</a> . <a href="androidenterprise_v1.installs.html">installs</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#delete">delete(enterpriseId, userId, deviceId, installId, x__xgafv=None)</a></code></p>
<p class="firstline">Requests to remove an app from a device. A call to <code>get</code> or</p>
<p class="toc_element">
  <code><a href="#get">get(enterpriseId, userId, deviceId, installId, x__xgafv=None)</a></code></p>
<p class="firstline">Retrieves details of an installation of an app on a device.</p>
<p class="toc_element">
  <code><a href="#list">list(enterpriseId, userId, deviceId, x__xgafv=None)</a></code></p>
<p class="firstline">Retrieves the details of all apps installed on the specified device.</p>
<p class="toc_element">
  <code><a href="#update">update(enterpriseId, userId, deviceId, installId, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Requests to install the latest version of an app to a device. If the app</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="delete">delete(enterpriseId, userId, deviceId, installId, x__xgafv=None)</code>
  <pre>Requests to remove an app from a device. A call to &lt;code&gt;get&lt;/code&gt; or
&lt;code&gt;list&lt;/code&gt; will still show the app as installed on the device until
it is actually removed.

Args:
  enterpriseId: string, The ID of the enterprise. (required)
  userId: string, The ID of the user. (required)
  deviceId: string, The Android ID of the device. (required)
  installId: string, The ID of the product represented by the install, e.g.
&quot;app:com.google.android.gm&quot;. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format
</pre>
</div>

<div class="method">
    <code class="details" id="get">get(enterpriseId, userId, deviceId, installId, x__xgafv=None)</code>
  <pre>Retrieves details of an installation of an app on a device.

Args:
  enterpriseId: string, The ID of the enterprise. (required)
  userId: string, The ID of the user. (required)
  deviceId: string, The Android ID of the device. (required)
  installId: string, The ID of the product represented by the install, e.g.
&quot;app:com.google.android.gm&quot;. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # The existence of an Installs resource indicates that an app is
      # installed on a particular device (or that an install is pending).
      #
      # The API can be used to create an install resource using the
      # &lt;a class=&quot;method-link&quot; method=&quot;androidenterprise.installs.update&quot;&gt;update&lt;/a&gt;
      # method. This triggers the actual install of the app on the device. If the
      # user does not already have an entitlement for the app, then an attempt is
      # made to create one. If this fails (for example, because the app is not free
      # and there is no available license), then the creation of the install fails.
      #
      # The API can also be used to update an installed app. If
      # the&amp;nbsp;&lt;a class=&quot;method-link&quot; method=&quot;androidenterprise.installs.update&quot;
      # style=&quot;font-style: normal; font-size: 14px; font-family: Roboto, sans-serif;
      # line-height: 22.3999996185303px;&quot;&gt;update&lt;/a&gt;&amp;nbsp;method is
      # used on an existing install, then the app will be updated to the latest
      # available version.
      #
      # Note that it is not possible to force the installation of a specific version
      # of an app: the version code is read-only.
      #
      # If a user installs an app themselves (as permitted by the enterprise), then
      # again an install resource and possibly an entitlement resource are
      # automatically created.
      #
      # The API can also be used to delete an install resource, which triggers the
      # removal of the app from the device. Note that deleting an install does not
      # automatically remove the corresponding entitlement, even if there are no
      # remaining installs. The install resource will also be deleted if the user
      # uninstalls the app themselves.
    &quot;versionCode&quot;: 42, # The version of the installed product. Guaranteed to be set only if the
        # install state is &lt;code&gt;&amp;quot;installed&amp;quot;&lt;/code&gt;.
    &quot;installState&quot;: &quot;A String&quot;, # Install state. The state &lt;code&gt;&amp;quot;installPending&amp;quot;&lt;/code&gt;
        # means that an install request has recently been made and download to the
        # device is in progress. The state &lt;code&gt;&amp;quot;installed&amp;quot;&lt;/code&gt;
        # means that the app has been installed. This field is read-only.
    &quot;productId&quot;: &quot;A String&quot;, # The ID of the product that the install is for. For example,
        # &lt;code&gt;&amp;quot;app:com.google.android.gm&amp;quot;&lt;/code&gt;.
  }</pre>
</div>

<div class="method">
    <code class="details" id="list">list(enterpriseId, userId, deviceId, x__xgafv=None)</code>
  <pre>Retrieves the details of all apps installed on the specified device.

Args:
  enterpriseId: string, The ID of the enterprise. (required)
  userId: string, The ID of the user. (required)
  deviceId: string, The Android ID of the device. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    {
    &quot;install&quot;: [ # An installation of an app for a user on a specific device.
        # The existence of an install implies that the user must have an
        # entitlement to the app.
      { # The existence of an Installs resource indicates that an app is
          # installed on a particular device (or that an install is pending).
          #
          # The API can be used to create an install resource using the
          # &lt;a class=&quot;method-link&quot; method=&quot;androidenterprise.installs.update&quot;&gt;update&lt;/a&gt;
          # method. This triggers the actual install of the app on the device. If the
          # user does not already have an entitlement for the app, then an attempt is
          # made to create one. If this fails (for example, because the app is not free
          # and there is no available license), then the creation of the install fails.
          #
          # The API can also be used to update an installed app. If
          # the&amp;nbsp;&lt;a class=&quot;method-link&quot; method=&quot;androidenterprise.installs.update&quot;
          # style=&quot;font-style: normal; font-size: 14px; font-family: Roboto, sans-serif;
          # line-height: 22.3999996185303px;&quot;&gt;update&lt;/a&gt;&amp;nbsp;method is
          # used on an existing install, then the app will be updated to the latest
          # available version.
          #
          # Note that it is not possible to force the installation of a specific version
          # of an app: the version code is read-only.
          #
          # If a user installs an app themselves (as permitted by the enterprise), then
          # again an install resource and possibly an entitlement resource are
          # automatically created.
          #
          # The API can also be used to delete an install resource, which triggers the
          # removal of the app from the device. Note that deleting an install does not
          # automatically remove the corresponding entitlement, even if there are no
          # remaining installs. The install resource will also be deleted if the user
          # uninstalls the app themselves.
        &quot;versionCode&quot;: 42, # The version of the installed product. Guaranteed to be set only if the
            # install state is &lt;code&gt;&amp;quot;installed&amp;quot;&lt;/code&gt;.
        &quot;installState&quot;: &quot;A String&quot;, # Install state. The state &lt;code&gt;&amp;quot;installPending&amp;quot;&lt;/code&gt;
            # means that an install request has recently been made and download to the
            # device is in progress. The state &lt;code&gt;&amp;quot;installed&amp;quot;&lt;/code&gt;
            # means that the app has been installed. This field is read-only.
        &quot;productId&quot;: &quot;A String&quot;, # The ID of the product that the install is for. For example,
            # &lt;code&gt;&amp;quot;app:com.google.android.gm&amp;quot;&lt;/code&gt;.
      },
    ],
  }</pre>
</div>

<div class="method">
    <code class="details" id="update">update(enterpriseId, userId, deviceId, installId, body=None, x__xgafv=None)</code>
  <pre>Requests to install the latest version of an app to a device. If the app
is already installed, then it is updated to the latest version if
necessary.

Args:
  enterpriseId: string, The ID of the enterprise. (required)
  userId: string, The ID of the user. (required)
  deviceId: string, The Android ID of the device. (required)
  installId: string, The ID of the product represented by the install, e.g.
&quot;app:com.google.android.gm&quot;. (required)
  body: object, The request body.
    The object takes the form of:

{ # The existence of an Installs resource indicates that an app is
    # installed on a particular device (or that an install is pending).
    # 
    # The API can be used to create an install resource using the
    # &lt;a class=&quot;method-link&quot; method=&quot;androidenterprise.installs.update&quot;&gt;update&lt;/a&gt;
    # method. This triggers the actual install of the app on the device. If the
    # user does not already have an entitlement for the app, then an attempt is
    # made to create one. If this fails (for example, because the app is not free
    # and there is no available license), then the creation of the install fails.
    # 
    # The API can also be used to update an installed app. If
    # the&amp;nbsp;&lt;a class=&quot;method-link&quot; method=&quot;androidenterprise.installs.update&quot;
    # style=&quot;font-style: normal; font-size: 14px; font-family: Roboto, sans-serif;
    # line-height: 22.3999996185303px;&quot;&gt;update&lt;/a&gt;&amp;nbsp;method is
    # used on an existing install, then the app will be updated to the latest
    # available version.
    # 
    # Note that it is not possible to force the installation of a specific version
    # of an app: the version code is read-only.
    # 
    # If a user installs an app themselves (as permitted by the enterprise), then
    # again an install resource and possibly an entitlement resource are
    # automatically created.
    # 
    # The API can also be used to delete an install resource, which triggers the
    # removal of the app from the device. Note that deleting an install does not
    # automatically remove the corresponding entitlement, even if there are no
    # remaining installs. The install resource will also be deleted if the user
    # uninstalls the app themselves.
  &quot;versionCode&quot;: 42, # The version of the installed product. Guaranteed to be set only if the
      # install state is &lt;code&gt;&amp;quot;installed&amp;quot;&lt;/code&gt;.
  &quot;installState&quot;: &quot;A String&quot;, # Install state. The state &lt;code&gt;&amp;quot;installPending&amp;quot;&lt;/code&gt;
      # means that an install request has recently been made and download to the
      # device is in progress. The state &lt;code&gt;&amp;quot;installed&amp;quot;&lt;/code&gt;
      # means that the app has been installed. This field is read-only.
  &quot;productId&quot;: &quot;A String&quot;, # The ID of the product that the install is for. For example,
      # &lt;code&gt;&amp;quot;app:com.google.android.gm&amp;quot;&lt;/code&gt;.
}

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # The existence of an Installs resource indicates that an app is
      # installed on a particular device (or that an install is pending).
      #
      # The API can be used to create an install resource using the
      # &lt;a class=&quot;method-link&quot; method=&quot;androidenterprise.installs.update&quot;&gt;update&lt;/a&gt;
      # method. This triggers the actual install of the app on the device. If the
      # user does not already have an entitlement for the app, then an attempt is
      # made to create one. If this fails (for example, because the app is not free
      # and there is no available license), then the creation of the install fails.
      #
      # The API can also be used to update an installed app. If
      # the&amp;nbsp;&lt;a class=&quot;method-link&quot; method=&quot;androidenterprise.installs.update&quot;
      # style=&quot;font-style: normal; font-size: 14px; font-family: Roboto, sans-serif;
      # line-height: 22.3999996185303px;&quot;&gt;update&lt;/a&gt;&amp;nbsp;method is
      # used on an existing install, then the app will be updated to the latest
      # available version.
      #
      # Note that it is not possible to force the installation of a specific version
      # of an app: the version code is read-only.
      #
      # If a user installs an app themselves (as permitted by the enterprise), then
      # again an install resource and possibly an entitlement resource are
      # automatically created.
      #
      # The API can also be used to delete an install resource, which triggers the
      # removal of the app from the device. Note that deleting an install does not
      # automatically remove the corresponding entitlement, even if there are no
      # remaining installs. The install resource will also be deleted if the user
      # uninstalls the app themselves.
    &quot;versionCode&quot;: 42, # The version of the installed product. Guaranteed to be set only if the
        # install state is &lt;code&gt;&amp;quot;installed&amp;quot;&lt;/code&gt;.
    &quot;installState&quot;: &quot;A String&quot;, # Install state. The state &lt;code&gt;&amp;quot;installPending&amp;quot;&lt;/code&gt;
        # means that an install request has recently been made and download to the
        # device is in progress. The state &lt;code&gt;&amp;quot;installed&amp;quot;&lt;/code&gt;
        # means that the app has been installed. This field is read-only.
    &quot;productId&quot;: &quot;A String&quot;, # The ID of the product that the install is for. For example,
        # &lt;code&gt;&amp;quot;app:com.google.android.gm&amp;quot;&lt;/code&gt;.
  }</pre>
</div>

</body></html>