preview/features/runtime-permissions.jd

page.title=Разрешения
page.tags=previewresources, androidm
page.keywords=разрешения, среда выполнения, предварительная версия
page.image={@docRoot}preview/features/images/permissions_check.png
@jd:body


<div id="qv-wrapper">
  <div id="qv">
    <h2>Краткое описание</h2>
    <ul>
      <li>Если ваше приложение предназначено для пакета SDK M Preview, пользователю будет предложено предоставить для него разрешения
 не в процессе установки, а при работе с приложением.</li>
      <li>Пользователь также может в любой момент отозвать разрешения, воспользовавшись экраном приложения «Настройки»
.</li>
      <li>Ваше приложение должно проверять наличие соответствующих разрешений при каждом запуске.
</li>
    </ul>

    <h2>Содержание документа</h2>
    <ol>
      <li><a href="#overview">Обзор</a></li>
      <li><a href="#coding">Добавление в код разрешений на выполнение</a></li>
      <li><a href="#testing">Тестирование разрешений на выполнение</a></li>
      <li><a href="#best-practices">Советы и рекомендации</a></li>
    </ol>

<!--
  <h2>Related Samples</h2>
  <ol>
    <li></li>
  </ol>
-->

<!--
  <h2>See also</h2>
  <ol>
    <li></li>
  </ol>
-->
  </div> <!-- qv -->
</div> <!-- qv-wrapper -->


<p>
  В версии M Developer Preview представлена новая модель разрешений для приложений, которая
оптимизирует для пользователей процесс установки и обновления приложений. Если приложение,
работающее в M Preview, поддерживает новую модель разрешений, пользователю не нужно предоставлять какие-либо
разрешения при установке приложения или его обновлении. Вместо этого приложение
запрашивает разрешения, когда в них возникает необходимость, — в таких случаях система отображает для пользователя диалоговое окно с просьбой предоставить
соответствующее разрешение.
</p>

<p>
  Если приложение поддерживает новую модель разрешений, его, тем не менее, можно установить и
запустить на устройстве под управлением одной из более ранних версий Android, и оно будет использовать старую модель
разрешений.
</p>

<h2 id="overview">
  Обзор
</h2>

<p>
  В версии M Developer Preview представлена новая
модель разрешений. Ниже приводится краткий обзор ее ключевых компонентов:
</p>

<ul>
  <li>
    <strong>Объявление разрешений.</strong> Все разрешения, которые требуются
приложению, объявляются в его манифесте, как и в более ранних версиях платформы Android.
  </li>

  <li>
    <strong>Группы разрешений.</strong> Разрешения
<em>группируются</em> по типу их функциональных возможностей. Например, в группе разрешений
<code>CONTACTS</code> находятся разрешения на чтение и запись
контактов пользователя и информации из его профиля.
  </li>

  <li>
    <p><strong>Ограниченные разрешения, предоставляемые во время установки.</strong> Когда
пользователь устанавливает или обновляет приложение, система предоставляет такому приложению все запрашиваемые им
разрешения, соответствующие константе {@link
android.content.pm.PermissionInfo#PROTECTION_NORMAL PROTECTION_NORMAL}.
    Например, разрешения для будильника и подключения к Интернету соответствуют константе {@link
android.content.pm.PermissionInfo#PROTECTION_NORMAL PROTECTION_NORMAL},
поэтому они предоставляются автоматически во время установки.
    </p>

    <p>Система также может предоставить приложению подпись и системные разрешения, как описано в разделе
<a href="#system-apps">Предоставление приложениям системных разрешений и
подписи</a>. Пользователю <em>не предлагается</em> предоставить какие-либо разрешения
во время установки.</p>
  </li>

  <li>
    <strong>Предоставление пользователем разрешений во время выполнения.</strong> Когда приложение запрашивает разрешение,
система отображает для пользователя соответствующее диалоговое окно, а затем вызывает функцию обратного вызова приложения
с целью уведомить его о том, предоставлены ли необходимые разрешения. Если
пользователь предоставляет разрешение, приложение получает весь набор разрешений в рамках данной функциональной области
разрешения, который был объявлен в манифесте приложения.
  </li>

</ul>

<p>
  Новая модель разрешений влияет на поведение приложений при работе с функциями, для
которых требуются разрешения. При использовании этой модели в разработке
 обратите внимание на следующие рекомендации:
</p>

<ul>

  <li>
    <strong>Всегда проверяйте наличие разрешений.</strong> Когда приложению необходимо выполнить
какое-либо действие, для которого требуется разрешение, оно должно сначала проверить,
имеется ли у него такое разрешение. Если разрешение отсутствует, приложение
должно запросить его.
  </li>

  <li>
    <strong>Если вам не дают разрешения, выходите из положения красиво.</strong> Если у приложения
нет нужного разрешения, оно должно обработать эту ошибку разумно.
    Например, если разрешение требуется лишь для необязательной функции, приложение может
просто отключить ее. Если же приложение не может работать без данного разрешения,
 оно может отключить все свои функциональные возможности и проинформировать пользователя,
что для работы ему требуется разрешение.
  </li>

  <div class="figure" style="width:220px" id="fig-perms-screen">
    <img src="{@docRoot}preview/features/images/app-permissions-screen_2x.png" srcset="{@docRoot}preview/features/images/app-permissions-screen.png 1x, {@docRoot}preview/features/images/app-permissions-screen_2x.png 2x" alt="" width="220">
    <p class="img-caption">
      <strong>Рисунок 1.</strong> Экран разрешений в настройках приложения.
    </p>
  </div>

  <li>
    <strong>Разрешения можно отзывать.</strong> Пользователи могут в любое время отозвать разрешения
приложения. Когда пользователь отзывает разрешения,
приложение <em>не</em> уведомляется об этом. Снова повторим, что приложение должно всегда проверять наличие
разрешений, прежде чем выполнять любые действия, для которых они необходимы.
  </li>
</ul>

<p class="note">
  <strong>Примечание.</strong> Если приложение предназначено для M Developer Preview, оно
<em>должно в обязательном порядке</em> использовать новую модель разрешений.
</p>

<p>
  На момент выпуска M Developer Preview не все приложения Google в полной мере реализуют
 новую модель разрешений. Google обновляет эти приложения
по мере разработки M Developer Preview, чтобы они должным образом поддерживали настройки
разрешений.
</p>

<p class="note">
  <strong>Примечание.</strong> Если у вашего приложения имеется собственная поверхность API-интерфейса, прежде чем проксировать
разрешения, убедитесь сначала в том, что у вызывающей операции имеются надлежащие
разрешения на доступ к данным.
</p>

<h3 id="system-apps">
  Предоставление приложениям системных разрешений и подписи
</h3>

<p>
  Как правило, когда пользователь устанавливает приложение, система предоставляет такому приложению только те
разрешения, которые соответствуют константе {@link android.content.pm.PermissionInfo#PROTECTION_NORMAL
PROTECTION_NORMAL}. Однако в определенных ситуациях система предоставляет
приложению больше разрешений:
</p>

<ul>
  <li>если приложение является частью системного образа, ему автоматически предоставляются все
разрешения, обозначенные в его манифесте;
  </li>

  <li>если в манифесте приложения запрашиваются разрешения, соответствующие константе {@link
android.content.pm.PermissionInfo#PROTECTION_SIGNATURE PROTECTION_SIGNATURE},
а для подписи приложения использовался то же сертификат, что и для приложения,
объявившего эти разрешения, система предоставляет запрашивающему приложению необходимые разрешения при
установке.
  </li>
</ul>

<p>
  В обоих случаях пользователь по-прежнему может в любое время отозвать разрешения, обратившись к
экрану <strong>Настройки</strong> и выбрав <strong>Приложения
&gt;</strong> <i>название_приложения</i> <strong>&gt; Разрешения</strong>. Поэтому приложение все равноу
должно проверять наличие разрешений во время выполнения и при необходимости запрашивать их.

</p>

<h3 id="compatibility">
  Совместимость с предыдущими и последующими версиями
</h3>

<p>
  Если приложение не предназначено для M Developer Preview, оно
продолжает использовать старую модель разрешений даже на устройствах под управлением M Preview. В таком случае при установке приложения
 система предлагает пользователю предоставить все разрешения,
указанные в манифесте приложения.
</p>

<p class="note">
  <strong>Примечание.</strong> На устройствах под управлением M Developer Preview пользователь может отключить
разрешения для любого приложения (включая устаревшие приложения) на экране «Настройки».
 Если пользователь решит отключить разрешения для устаревших приложений, система
автоматически отключит соответствующие функциональные возможности. Когда приложение пытается
выполнить операцию, для которой требуется такое разрешение, это
не обязательно приведет к возникновению исключения. Вместо этого оно может выдать пустой набор данных,
сигнал об ошибке или иным образом обозначить непредвиденное поведение. Например, если запросить
календарь, не имея соответствующего разрешения, метод возвратит пустой набор данных.
</p>

<p>
  При установке приложения с использованием новой модели разрешений на устройство
под управлением другой версии ОС, отличной от M Preview,
система рассматривает такое приложение как любое другое и предлагает
пользователю предоставить все объявленные разрешения уже во время установки.
</p>

<p class="note">
  <strong>Примечание.</strong> В случае с предварительной версией в качестве минимальной версии пакета SDK
следует задать версию SDK M Preview, чтобы получить возможность компилировать код с помощью пакета SDK предварительной версии. Это означает,
что вы не сможете протестировать такие приложения на старых платформах
во время использования предварительной версии для разработчиков.
</p>

<h3 id="perms-vs-intents">Разрешения и намерения</h3>

<p>
  Во многих случаях при разработке приложения у вас есть выбор между двумя способами выполнения задачи:
 вы можете настроить приложение таким образом, чтобы оно самостоятельно запрашивало соответствующие разрешения на выполнение
операции, или же можно указать ему использовать намерение, чтобы задачу выполнило
другое приложение.
</p>

<p>
  Например, предположим, что вашему приложению требуется возможность делать снимки с помощью камеры устройства.
 Ваше приложение может запросить разрешение
<code>android.permission.CAMERA</code>, которое позволит ему напрямую получить доступ
к камере. Затем ваше приложение использует API-интерфейсы камеры
для управления камерой и получения снимков. Благодаря такому подходу ваше приложение получает
полный контроль над процессом фотографирования. Кроме того, это позволяет вам вставить пользовательский интерфейс камеры
в свое приложение.
</p>

<p>
  Если же вам не требуется такой контроль, просто воспользуйтесь намерением {@link
android.provider.MediaStore#ACTION_IMAGE_CAPTURE ACTION_IMAGE_CAPTURE}
для запроса изображения. Когда вы запускаете намерение, пользователю предлагается выбрать
приложение камеры (если оно отличается от приложения камеры по умолчанию), после чего
это приложение делает снимок. Приложение камеры возвращает полученное изображение в метод {@link
android.app.Activity#onActivityResult onActivityResult()} вашего приложения.
</p>

<p>
  Аналогичным образом, если вам необходимо позвонить, получить доступ к контактам пользователя и так далее,
можно создать соответствующее намерение или запросить
разрешение и напрямую получить доступ к нужным объектам. У каждого подхода есть
как преимущества, так и недостатки.
</p>

<p>
  При использовании разрешений:
</p>

<ul>
  <li>Ваше приложение получает полный контроль над взаимодействием пользователя с интерфейсом во время выполнения
операции. Однако такой широкий контроль усложняет вашу задачу,
требуя разработать подходящий пользовательский интерфейс.
  </li>

  <li>Пользователю предлагается предоставить разрешения только один раз, при первом
выполнении операции. После этого ваше приложение может выполнять операцию без вмешательства
со стороны пользователя. Однако если пользователь не
предоставит разрешение (или отзовет его позже), ваше приложение не сможет выполнить
операцию.
  </li>
</ul>

<p>
  При использовании намерений:
</p>

<ul>
  <li>Вам не нужно разрабатывать пользовательский интерфейс для выполнения операции, его предоставляет приложение, которое обрабатывает
намерение. Однако это также означает, что у вас отсутствует контроль над
взаимодействием пользователя с интерфейсом. Возможно, пользователю придется взаимодействовать с
приложением, которое вы даже не видели.
  </li>

  <li>Если у пользователя нет приложения по умолчанию для выполнения операции, система
предлагает ему выбрать приложение. Если пользователь не назначит обработчик
по умолчанию, то при каждом выполнении операции для него может
отображаться дополнительное диалоговое окно.
  </li>
</ul>

<h2 id="coding">Добавление в код разрешений на выполнение</h2>

<p>
  Если ваше приложение предназначено для новой версии M Developer Preview, вы должны в обязательном порядке использовать
новую модель разрешений. Это означает, что кроме объявления требуемых разрешений
в манифесте, вам следует проверять наличие этих разрешений
во время выполнения, а также запрашивать их, если у вас
еще нет необходимых разрешений.
</p>

<h3 id="enabling">
  Активация новой модели разрешений
</h3>

<p>
  Чтобы активировать новую модель разрешений M Developer Preview, задайте для атрибута
<code>targetSdkVersion</code> приложения значение <code>"MNC"</code>, а для атрибута
<code>compileSdkVersion</code> – значение <code>"android-MNC"</code>. Это позволит
включить все функции новой модели разрешений.
</p>

<p>
  В случае с предварительной версией необходимо задать для параметра <code>minSdkVersion</code> значение
<code>"MNC"</code>, чтобы получить возможность компилировать код с помощью пакета SDK предварительной версии.
</p>

<h3 id="m-only-perm">
  Назначение разрешений только для M Preview
</h3>

<p>
  В манифесте приложения можно использовать новый элемент <code>&lt;uses-permission-sdk-m&gt;</code>,
чтобы указать, что разрешение требуется только для M Developer Preview. Если объявить
разрешение таким способом, то при установке приложения на устройство с более старой версией платформы
система не будет отправлять запрос пользователю или предоставлять разрешение приложению.
С помощью элемента <code>&lt;uses-permission-sdk-m&gt;</code>
вы можете добавлять новые разрешения
в обновленные версии вашего приложения без принудительного запроса у пользователей разрешений при
установке обновления.
</p>

<p>
  Если приложение запущено на устройстве под управлением M Developer Preview,
поведение элемента <code>&lt;uses-permission-sdk-m&gt;</code> аналогично поведению
<code><a href="{@docRoot}guide/topics/manifest/uses-permission-element.html">&lt;uses-permission&gt;</a></code>.
  Система не запрашивает у пользователей предоставление каких-либо разрешений, когда они устанавливают
приложение. Вместо этого приложение само запрашивает разрешения, когда они требуются.
</p>

<h3 id="prompting">
  Запрос разрешений
</h3>

<p>
  Если ваше приложение использует новую модель разрешений M Developer Preview, то при первом запуске приложения
на устройстве под управлением
M Preview пользователю не предлагается предоставить все разрешения. Вместо этого приложение само запрашивает разрешения, когда они
требуются. Когда приложение запрашивает разрешение, система отображает для пользователя соответствующее диалоговое
окно.
</p>

<p>
  Если ваше приложение запущено на устройстве с пакетом SDK уровня 22 или более низкого, то приложение использует старую
модель разрешений. То есть при каждой устновке приложения пользователю будет предложено предоставить приложению все разрешения,
запрашиваемые в манифесте приложения, кроме
отмеченных элементом <code>&lt;uses-permission-sdk-m&gt;</code>.
</p>

<h4 id="check-platform">Проверка платформы, на которой выполняется приложение</h4>

<p>
  Новая модель разрешений поддерживается только на устройствах под управлением M Developer
Preview. Прежде чем вызывать любые из этих методов, приложению следует проверить,
на какой платформе оно выполняется,
обратившись к значению параметра {@link android.os.Build.VERSION#CODENAME
Build.VERSION.CODENAME}. Если устройство работает под управлением M Developer Preview,
то значение параметра{@link android.os.Build.VERSION#CODENAME CODENAME} будет <code>"MNC"</code>.
</p>

<h4 id="check-for-permission">Проверка наличия у приложения необходимого разрешения</h4>

<p>Когда пользователи пытаются выполнить какое-либо действие, для которого требуется разрешение, приложение
проверяет, имеется ли у него в настоящее время разрешение на выполнение этой операции. Для этого
приложение вызывает метод
<code>Context.checkSelfPermission(<i>permission_name</i>)</code>. Приложению
следует выполнять такую проверку даже в том случае, если ему известно, что пользователь уже предоставил
необходимое разрешение,
поскольку пользователь может в любое время отозвать разрешения приложения. Например, если пользователь
хочет получить снимок с помощью приложения, то приложение вызывает метод
<code>Context.checkSelfPermission(Manifest.permission.CAMERA)</code>.</p>

<p class="table-caption" id="permission-groups">
  <strong>Таблица 1.</strong> Разрешения и группы разрешений.</p>
<table>
  <tr>
    <th scope="col">Группа разрешений</th>
    <th scope="col">Разрешения</th>
  </tr>

  <tr>
    <td><code>android.permission-group.CALENDAR</code></td>
    <td>
      <ul>
        <li>
          <code>android.permission.READ_CALENDAR</code>
        </li>
      </ul>
      <ul>
        <li>
          <code>android.permission.WRITE_CALENDAR</code>
        </li>
      </ul>
    </td>
  </tr>

  <tr>
    <td><code>android.permission-group.CAMERA</code></td>
    <td>
      <ul>
        <li>
          <code>android.permission.CAMERA</code>
        </li>
      </ul>
    </td>
  </tr>

  <tr>
    <td><code>android.permission-group.CONTACTS</code></td>
    <td>
      <ul>
        <li>
          <code>android.permission.READ_CONTACTS</code>
        </li>
        <li>
          <code>android.permission.WRITE_CONTACTS</code>
        </li>
        <li>
          <code>android.permission.READ_PROFILE</code>
        </li>
        <li>
          <code>android.permission.WRITE_PROFILE</code>
        </li>
      </ul>
    </td>
  </tr>

  <tr>
    <td><code>android.permission-group.LOCATION</code></td>
    <td>
      <ul>
        <li>
          <code>android.permission.ACCESS_FINE_LOCATION</code>
        </li>
        <li>
          <code>android.permission.ACCESS_COARSE_LOCATION</code>
        </li>
      </ul>
    </td>
  </tr>

  <tr>
    <td><code>android.permission-group.MICROPHONE</code></td>
    <td>
      <ul>
        <li>
          <code>android.permission.RECORD_AUDIO</code>
        </li>
      </ul>
    </td>
  </tr>

  <tr>
    <td><code>android.permission-group.PHONE</code></td>
    <td>
      <ul>
        <li>
          <code>android.permission.READ_PHONE_STATE</code>
        </li>
        <li>
          <code>android.permission.CALL_PHONE</code>
        </li>
        <li>
          <code>android.permission.READ_CALL_LOG</code>
        </li>
        <li>
          <code>android.permission.WRITE_CALL_LOG</code>
        </li>
        <li>
          <code>com.android.voicemail.permission.ADD_VOICEMAIL</code>
        </li>
        <li>
          <code>android.permission.USE_SIP</code>
        </li>
        <li>
          <code>android.permission.PROCESS_OUTGOING_CALLS</code>
        </li>
      </ul>
    </td>
  </tr>

  <tr>
    <td><code>android.permission-group.SENSORS</code></td>
    <td>
      <ul>
        <li>
          <code>android.permission.BODY_SENSORS</code>
        </li>
      </ul>
      <ul>
        <li>
          <code>android.permission.USE_FINGERPRINT</code>
        </li>
      </ul>
    </td>
  </tr>

  <tr>
    <td><code>android.permission-group.SMS</code></td>
    <td>
      <ul>
        <li>
          <code>android.permission.SEND_SMS</code>
        </li>
        <li>
          <code>android.permission.RECEIVE_SMS</code>
        </li>
        <li>
          <code>android.permission.READ_SMS</code>
        </li>
        <li>
          <code>android.permission.RECEIVE_WAP_PUSH</code>
        </li>
        <li>
          <code>android.permission.RECEIVE_MMS</code>
        </li>
        <li>
          <code>android.permission.READ_CELL_BROADCASTS</code>
        </li>
      </ul>
    </td>
  </tr>

</table>

<h4 id="request-permissions">Запрос разрешений при необходимости</h4>

<p>Если у приложения нет требуемого разрешения, оно вызывает метод
<code>Activity.requestPermissions(String[], int)</code>, чтобы запросить его.
 Приложение передает в него
требуемые разрешения, а также целочисленный код запроса.
  Этот метод выполняется асинхронно: он возвращает результат сразу же, а после того как пользователь
предоставляет ответ в диалоговом окне, система вызывает метод обратного вызова
приложения с результатами и передает в него тот же код запроса, который приложение передало в метод
<code>requestPermissions()</code>.</p>

  <p>Ниже представлен пример кода для проверки наличия у приложения разрешения на чтение контактов
пользователя и запроса соответствующего разрешения при необходимости.</p>

<pre>
if (checkSelfPermission(Manifest.permission.READ_CONTACTS)
        != PackageManager.PERMISSION_GRANTED) {
    requestPermissions(new String[]{Manifest.permission.READ_CONTACTS},
            MY_PERMISSIONS_REQUEST_READ_CONTACTS);

    // MY_PERMISSIONS_REQUEST_READ_CONTACTS is an
    // app-defined int constant

    return;
}
</pre>

<h4 id="handle-response">Обработка ответа на запрос разрешений</h4>

<p>
  Когда приложение запрашивает разрешения, система отображает для пользователя соответствующее диалоговое
окно. После получения ответа от пользователя система вызывает метод
<code>Activity.onRequestPermissionsResult(int, String[], int[])</code>
вашего приложения и передает в него ответ пользователя. Вашему приложению необходимо переопределить этот метод. В обратном
вызове передается тот же код запроса, который вы передали в метод
<code>requestPermissions()</code>. Например, если приложение запрашивает доступ на
<code>READ_CONTACTS</code>, то метод обратного вызова
может быть следующим:
</p>

<pre>
&#64;Override
public void onRequestPermissionsResult(int requestCode,
        String permissions[], int[] grantResults) {
    switch (requestCode) {
        case MY_PERMISSIONS_REQUEST_READ_CONTACTS: {
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                // permission was granted, yay! do the
                // calendar task you need to do.

            } else {

                // permission denied, boo! Disable the
                // functionality that depends on this permission.
            }
            return;
        }

        // other 'switch' lines to check for other
        // permissions this app might request
    }
}
</pre>

  <p>Если пользователь предоставляет разрешение, система, в свою очередь, представляет все разрешения,
запрашиваемые в манифесте приложения для обозначенной функциональной области. Если пользователь
отказывает в предоставлении разрешения, вам необходимо принять меры. Например, вы можете отключить любые пункты меню
, для использования которых требуется это разрешение.
  </li>
</p>

<p>
  Когда система предлагает пользователю предоставить разрешение, он может указать системе,
чтобы она больше не запрашивала это разрешение. В этом случае,
когда приложение использует метод <code>requestPermissions()</code> для запроса такого разрешения,
система сразу же отклоняет запрос. При этом система вызывает ваш метод
<code>onRequestPermissionsResult()</code> так же, как если бы пользователь повторно
отклонил ваш запрос. Поэтому ваше приложение
не считает, что имело место прямое взаимодействие с пользователем.
</p>

<h2 id="testing">Тестирование разрешений на выполнение</h2>


<p>
  Если ваше приложение предназначено для новой версии M Developer Preview, то вы должны протестировать
его и убедиться в том, что оно должным образом обрабатывает разрешения. Не надо исходить из того, что к началу работы ваше приложение уже имеет
любые определенные разрешения. При первом запуске приложения оно,
скорее всего, не будет обладать разрешениями, а в дальнейшем пользователь может в любой момент отозвать или восстановить
разрешения.
</p>

<p>
  Вам следует протестировать ваше приложение и убедиться в том, что оно ведет себя должным образом в
любых ситуациях, касающихся разрешений. Мы включили в состав пакета SDK M Preview SDK новые команды
<a href="{@docRoot}tools/help/adb.html">Android
Debug Bridge (ADB)</a>, чтобы вы могли протестировать ваше приложение с любыми настройками разрешений,
которые вы хотите попробовать в действии.
</p>

<h3>
  Новые команды и параметры ADB
</h3>

<p>
  В состав пакета инструментов SDK M Preview входит ряд новых команд, позволяющих протестировать обработку разрешений
вашим приложением.
</p>

<h4>
  Установка с разрешениями
</h4>

<p>
  Можно воспользоваться новым параметром <code>-g</code> команды <a href="{@docRoot}tools/help/adb.html#move"><code>adb
  install</code></a>, который служит для установки
приложения и предоставления всех разрешений, указанных в его манифесте:
</p>

<pre class="no-pretty-print">
$ adb install -g &lt;path_to_apk&gt;
</pre>

<h4>
  Предоставление разрешений и их отзыв
</h4>

<p>
  Для предоставления разрешений установленному приложению и их отзыва можно использовать новые команды <a href="{@docRoot}tools/help/adb.html#pm">диспетчера пакетов</a>
ADB.
Такая функциональная возможность может быть полезна для автоматизированного тестирования.
</p>

<p>
  Для представления разрешения используйте команду <code>grant</code> диспетчера пакетов:
</p>

<pre class="no-pretty-print">
$ adb pm grant &lt;package_name&gt; &lt;permission_name&gt;
</pre>

<p>
  Например, чтобы представить пакету com.example.myapp разрешение на запись
аудио, воспользуйтесь следующей командой:
</p>

<pre class="no-pretty-print">
$ adb pm grant com.example.myapp android.permission.RECORD_AUDIO
</pre>

<p>
  Чтобы отозвать разрешение, используйте команду <code>revoke</code> диспетчера пакетов:
</p>

<pre class="no-pretty-print">
$ adb pm revoke &lt;package_name&gt; &lt;permission_name&gt;
</pre>

<h2 id="best-practices">Советы и рекомендации</h2>

<p>
  Новая модель разрешений делает работу пользователей удобнее,
упрощает для них процесс установки приложений и позволяет лучше понимать,
что делает то или иное приложение. Чтобы использовать все преимущества
этой модели, примите во внимание следующие рекомендации:
</p>


<h3 id="bp-what-you-need">Запрашивайте только те разрешения, которые необходимы</h3>

<p>
  Каждый раз, когда вы запрашиваете разрешение, вы заставляете пользователя делать выбор.
  Если пользователь отклоняет запрос, соответствующая функциональная возможность приложения отключается.
  Вам следует сократить количество таких запросов.
</p>

<p>
  Например, во многих случаях можно предоставить приложению доступ к нужной функции посредством
<a href="{@docRoot}guide/components/intents-filters.html">намерения</a> вместо
запроса разрешений. Если вашему приложению необходимо получить снимки с камеры
телефона, можно использовать намерение {@link
android.provider.MediaStore#ACTION_IMAGE_CAPTURE
MediaStore.ACTION_IMAGE_CAPTURE}. Когда ваше приложение выполняет намерение, система
предлагает пользователю выбрать уже установленное приложение камеры для
получения снимков.
</p>

<h3 id="bp-dont-overwhelm">
  Не перегружайте пользователя запросами
</h3>

<p>
  Если на пользователя обрушивается сразу много запросов разрешений, он может
решить, что все это слишком сложно, и просто закрыть приложение. Поэтому разрешения следует
запрашивать только тогда, когда это необходимо.
</p>

<p>
  Иногда приложению жизненно необходимы одно или несколько разрешений.
В таких случаях имеет смысл запросить все разрешения
сразу при запуске приложения. Например, если вы разрабатываете приложение для фотографирования, то ему
однозначно потребуется доступ к камере устройства. Когда пользователь в первый раз запускает приложение,
он не удивится, если приложение запросит у него разрешение на
использование камеры. Однако если в этом же приложении имеется функция обмена фотографиями с
контактами пользователя, возможно, <em>не следует</em> запрашивать соответствующее разрешение при
первом запуске приложения. Лучше дождаться, когда пользователю потребуется функция обмена контентом,
и уже тогда запросить разрешение.
</p>

<p>
  Если в вашем приложении имеются обучающие материалы, может оказаться целесообразным запросить необходимые разрешения
после того, как пользователь изучит материалы.
</p>

<h3 id="bp-explain">
  Всегда поясняйте, для чего требуются те или иные разрешения
</h3>

<p>
  В диалоговом окне запроса разрешений, которое система отображает при вызове вами метода
<code>requestPermissions()</code>, обозначается требуемое для приложения разрешение,
однако не указывается, для чего оно необходимо. В некоторых случаях это может озадачить пользователя.
  Поэтому, прежде чем вызывать метод
<code>requestPermissions()</code>, стоит пояснить пользователю, для чего вашему приложению требуются разрешения.
</p>

<p>
  Например, приложению для фотографирования может потребоваться доступ к службам геолокации, чтобы фотографии можно было снабдить
геотегами. Не все пользователи знают, что
фотография может содержать данные о месте съемки, и им может показаться странным, что приложение для фотографирования запрашивает данные
о местоположении. В этом случае полезно
рассказать пользователю о такой возможности, <em>прежде</em> чем вызывать метод
<code>requestPermissions()</code>.
</p>

<p>
  Это можно сделать, в частности, внедрив такие запросы в обучающие материалы приложения. В обучающих
материалах могут содержаться описания каждой из функций приложения с пояснением,
какие разрешения необходимы для их использования. Например, в обучающий материал по работе с приложением для фотографирования
можно включить описание функции обмена контентом с контактами, после чего
пояснить, что для этого пользователю следует предоставить приложению доступ к его контактам.
 После этого приложение может вызвать метод <code>requestPermissions()</code> для запроса
доступа. Конечно, не все пользователи обращаются к обучающим материалам,
поэтому вам по-прежнему следует проверять наличие разрешений и при необходимости запрашивать
их во время обычной работы приложения.
</p>