5.2.1 示例代码

5.2.1.1 如何使用 Android OS 的系统权限

Android 操作系统有一个称为“权限”的安全机制，可以保护其用户的资产（如联系人和 GPS 功能）免受恶意软件的侵害。 当应用请求访问受 Android OS 保护的信息或功能时，应用需要显式声明权限才能访问它们。 安装应用，它申请需要用户同意的权限时，会出现以下确认界面 [23]。

[23] 在 Android 6.0（API Level 23）及更高版本中，安装应用时不会发生用户的权限授予或拒绝，而是在应用请求权限时在运行时发生。 更多详细信息，请参见“5.2.1.4 在 Android 6.0 及更高版本中使用危险权限的方法”和“5.2.3.6 Android 6.0 和更高版本中的权限模型规范的修改”部分。

5.2.1.md - 图1

从该确认界面中，用户能够知道，应用试图访问哪些类型的特征或信息。 如果应用试图访问明显不需要的功能或信息，那么该应用很可能是恶意软件。 因此，为了使你的应用不被怀疑是恶意软件，因此需要尽量减少使用权限声明。

要点：

  1. 使用uses-permission声明应用中使用的权限。
  2. 不要用uses-permission声明任何不必要的权限。

AndroidManifest.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="org.jssec.android.permission.usespermission" >
  4.     <!-- *** POINT 1 *** Declare a permission used in an application with uses-permission -->
  5.     <!-- Permission to access Internet -->
  6.     <uses-permission android:name="android.permission.INTERNET"/>
  7.     <!-- *** POINT 2 *** Do not declare any unnecessary permissions with uses-permission -->
  8.     <!-- If declaring to use Permission that is unnecessary for application behaviors, it gives users a
  9.     sense of distrust. -->
  10.     <application
  11.         android:allowBackup="false"
  12.         android:icon="@drawable/ic_launcher"
  13.         android:label="@string/app_name" >
  14.         <activity
  15.             android:name=".MainActivity"
  16.             android:label="@string/app_name"
  17.             android:exported="true" >
  18.             <intent-filter>
  19.                 <action android:name="android.intent.action.MAIN" />
  20.                 <category android:name="android.intent.category.LAUNCHER" />
  21.             </intent-filter>
  22.         </activity>
  23.     </application>
  24. </manifest>

5.2.1.2 如何使用内部定义的权限在内部应用之间通信

除了由 Android OS 定义的系统权限之外，应用还可以定义自己的权限。 如果使用内部定义的权限（内部定义的签名权限更准确），则可以构建只允许内部应用之间进行通信的机制。 通过提供基于多个内部应用之间的，应用间通信的复合功能，应用变得更具吸引力，你的企业可以通过将其作为系列销售获得更多利润。 这是使用内部定义的签名权限的情况。

示例应用“内部定义的签名权限（UserApp）”使用Context.startActivity()方法启动示例应用“内部定义的签名权限（ProtectedApp）”。 两个应用都需要使用相同的开发人员密钥进行签名。如果用于签名的密钥不同，则UserApp不会向ProtectedApp发送意图，并且ProtectedApp不处理从UserApp收到的意图。 此外，它还可以防止恶意软件使用安装顺序相关的事项，绕过你自己的签名权限，如高级话题部分中所述。

5.2.1.md - 图2

要点：提供组件的应用

  1. 使用protectionLevel="signature"定义权限。

  2. 对于组件，使用其权限属性强制规定权限。

  3. 如果组件是活动，则必须没有定义意图过滤器。

  4. 在运行时，验证签名权限是否由程序代码本身定义。

  5. 导出 APK 时，请使用与使用该组件的应用相同的开发人员密钥对 APK 进行签名。

AndroidManifest.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="org.jssec.android.permission.protectedapp" >
  4.     <!-- *** POINT 1 *** Define a permission with protectionLevel="signature" -->
  5.     <permission
  6.         android:name="org.jssec.android.permission.protectedapp.MY_PERMISSION"
  7.         android:protectionLevel="signature" />
  8.     <application
  9.         android:allowBackup="false"
  10.         android:icon="@drawable/ic_launcher"
  11.         android:label="@string/app_name" >
  12.         <!-- *** POINT 2 *** For a component, enforce the permission with its permission attribute -->
  13.         <activity
  14.             android:name=".ProtectedActivity"
  15.             android:exported="true"
  16.             android:label="@string/app_name"
  17.             android:permission="org.jssec.android.permission.protectedapp.MY_PERMISSION" >
  18.             <!-- *** POINT 3 *** If the component is an activity, you must define no intent-filter -->
  19.         </activity>
  20.     </application>
  21. </manifest>

ProtectedActivity.java

  1. package org.jssec.android.permission.protectedapp;
  3. import org.jssec.android.shared.SigPerm;
  4. import org.jssec.android.shared.Utils;
  5. import android.app.Activity;
  6. import android.content.Context;
  7. import android.os.Bundle;
  8. import android.widget.TextView;
  10. public class ProtectedActivity extends Activity {
  12.     // In-house Signature Permission
  13.     private static final String MY_PERMISSION = "org.jssec.android.permission.protectedapp.MY_PERMISSION";
  14.     // Hash value of in-house certificate
  15.     private static String sMyCertHash = null;
  17.     private static String myCertHash(Context context) {
  18.         if (sMyCertHash == null) {
  19.             if (Utils.isDebuggable(context)) {
  20.                 // Certificate hash value of "androiddebugkey" of debug.keystore
  21.                 sMyCertHash = "0EFB7236 328348A9 89718BAD DF57F544 D5CCB4AE B9DB34BC 1E29DD26 F77C8255";
  22.             } else {
  23.                 // Certificate hash value of "my company key" of keystore
  24.                 sMyCertHash = "D397D343 A5CBC10F 4EDDEB7C A10062DE 5690984F 1FB9E88B D7B3A7C2 42E142CA";
  25.             }
  26.         }
  27.         return sMyCertHash;
  28.     }
  30.     private TextView mMessageView;
  32.     @Override
  33.     public void onCreate(Bundle savedInstanceState) {
  34.         super.onCreate(savedInstanceState);
  35.         setContentView(R.layout.main);
  36.         mMessageView = (TextView) findViewById(R.id.messageView);
  37.         // *** POINT 4 *** At run time, verify if the signature permission is defined by itself on the program code
  38.         if (!SigPerm.test(this, MY_PERMISSION, myCertHash(this))) {
  39.             mMessageView.setText("In-house defined signature permission is not defined by in-house application.");
  40.             return;
  41.         }
  42.         // *** POINT 4 *** Continue processing only when the certificate matches
  43.         mMessageView.setText("In-house-defined signature permission is defined by in-house application,
  44.         was confirmed.");
  45.     }
  46. }

SigPerm.java

  1. package org.jssec.android.shared;
  3. import android.content.Context;
  4. import android.content.pm.PackageManager;
  5. import android.content.pm.PackageManager.NameNotFoundException;
  6. import android.content.pm.PermissionInfo;
  8. public class SigPerm {
  10.     public static boolean test(Context ctx, String sigPermName, String correctHash) {
  11.         if (correctHash == null) return false;
  12.         correctHash = correctHash.replaceAll(" ", "");
  13.         return correctHash.equals(hash(ctx, sigPermName));
  14.     }
  16.     public static String hash(Context ctx, String sigPermName) {
  17.         if (sigPermName == null) return null;
  18.         try {
  19.             // Get the package name of the application which declares a permission named sigPermName.
  20.             PackageManager pm = ctx.getPackageManager();
  21.             PermissionInfo pi;
  22.             pi = pm.getPermissionInfo(sigPermName, PackageManager.GET_META_DATA);
  23.             String pkgname = pi.packageName;
  24.             // Fail if the permission named sigPermName is not a Signature Permission
  25.             if (pi.protectionLevel != PermissionInfo.PROTECTION_SIGNATURE) return null;
  26.             // Return the certificate hash value of the application which declares a permission named sigPermName.
  27.             return PkgCert.hash(ctx, pkgname);
  28.         } catch (NameNotFoundException e) {
  29.             return null;
  30.         }
  31.     }
  32. }

PkgCert.java

  1. package org.jssec.android.shared;
  3. import java.security.MessageDigest;
  4. import java.security.NoSuchAlgorithmException;
  5. import android.content.Context;
  6. import android.content.pm.PackageInfo;
  7. import android.content.pm.PackageManager;
  8. import android.content.pm.PackageManager.NameNotFoundException;
  9. import android.content.pm.Signature;
  11. public class PkgCert {
  13.     public static boolean test(Context ctx, String pkgname, String correctHash) {
  14.         if (correctHash == null) return false;
  15.         correctHash = correctHash.replaceAll(" ", "");
  16.         return correctHash.equals(hash(ctx, pkgname));
  17.     }
  19.     public static String hash(Context ctx, String pkgname) {
  20.         if (pkgname == null) return null;
  21.         try {
  22.             PackageManager pm = ctx.getPackageManager();
  23.             PackageInfo pkginfo = pm.getPackageInfo(pkgname, PackageManager.GET_SIGNATURES);
  24.             if (pkginfo.signatures.length != 1) return null; // Will not handle multiple signatures.
  25.             Signature sig = pkginfo.signatures[0];
  26.             byte[] cert = sig.toByteArray();
  27.             byte[] sha256 = computeSha256(cert);
  28.             return byte2hex(sha256);
  29.         } catch (NameNotFoundException e) {
  30.             return null;
  31.         }
  32.     }
  34.     private static byte[] computeSha256(byte[] data) {
  35.         try {
  36.             return MessageDigest.getInstance("SHA-256").digest(data);
  37.         } catch (NoSuchAlgorithmException e) {
  38.             return null;
  39.         }
  40.     }
  42.     private static String byte2hex(byte[] data) {
  43.         if (data == null) return null;
  44.         final StringBuilder hexadecimal = new StringBuilder();
  45.         for (final byte b : data) {
  46.             hexadecimal.append(String.format("%02X", b));
  47.         }
  48.         return hexadecimal.toString();
  49.     }
  50. }

要点 5：导出 APK 时，请使用与使用该组件的应用相同的开发人员密钥对 APK 进行签名。

5.2.1.md - 图3

要点：使用组件的应用

  1. 禁止定义应用使用的相同签名权限。

  2. 使用权限标签声明内部权限。

  3. 验证内部签名权限，是否由提供组件的应用定义。

  4. 验证目标应用是否是内部应用。

  5. 当目标组件是一个活动时，使用显式意图。

  6. 导出 APK 时，请使用与使用该组件的应用相同的开发人员密钥对 APK 进行签名。

AndroidManifest.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="org.jssec.android.permission.userapp" >
  4.     <!-- *** POINT 6 *** The same signature permission that the application uses must not be defined -->
  5.     <!-- *** POINT 7 *** Declare the in-house permission with uses-permission tag -->
  6.     <uses-permission
  7.     android:name="org.jssec.android.permission.protectedapp.MY_PERMISSION" />
  8.     <application
  9.         android:allowBackup="false"
  10.         android:icon="@drawable/ic_launcher"
  11.         android:label="@string/app_name" >
  12.         <activity
  13.         android:name=".UserActivity"
  14.             android:label="@string/app_name"
  15.             android:exported="true" >
  16.             <intent-filter>
  17.                 <action android:name="android.intent.action.MAIN" />
  18.                 <category android:name="android.intent.category.LAUNCHER" />
  19.             </intent-filter>
  20.         </activity>
  21.     </application>
  22. </manifest>

UserActivity.java

  1. package org.jssec.android.permission.userapp;
  3. import org.jssec.android.shared.PkgCert;
  4. import org.jssec.android.shared.SigPerm;
  5. import org.jssec.android.shared.Utils;
  6. import android.app.Activity;
  7. import android.content.Context;
  8. import android.content.Intent;
  9. import android.os.Bundle;
  10. import android.view.View;
  11. import android.widget.Toast;
  13. public class UserActivity extends Activity {
  15.     // Requested (Destination) application's Activity information
  16.     private static final String TARGET_PACKAGE = "org.jssec.android.permission.protectedapp";
  17.     private static final String TARGET_ACTIVITY = "org.jssec.android.permission.protectedapp.ProtectedActivity";
  18.     // In-house Signature Permission
  19.     private static final String MY_PERMISSION = "org.jssec.android.permission.protectedapp.MY_PERMISSION";
  20.     // Hash value of in-house certificate
  21.     private static String sMyCertHash = null;
  23.     private static String myCertHash(Context context) {
  24.         if (sMyCertHash == null) {
  25.             if (Utils.isDebuggable(context)) {
  26.                 // Certificate hash value of "androiddebugkey" of debug.keystore.
  27.                 sMyCertHash = "0EFB7236 328348A9 89718BAD DF57F544 D5CCB4AE B9DB34BC 1E29DD26 F77C8255";
  28.             } else {
  29.                 // Certificate hash value of "my company key" of keystore.
  30.                 sMyCertHash = "D397D343 A5CBC10F 4EDDEB7C A10062DE 5690984F 1FB9E88B D7B3A7C2 42E142CA";
  31.             }
  32.         }
  33.         return sMyCertHash;
  34.     }
  36.     @Override
  37.     public void onCreate(Bundle savedInstanceState) {
  38.         super.onCreate(savedInstanceState);
  39.         setContentView(R.layout.main);
  40.     }
  42.     public void onSendButtonClicked(View view) {
  43.         // *** POINT 8 *** Verify if the in-house signature permission is defined by the application that provides the component on the program code.
  44.         if (!SigPerm.test(this, MY_PERMISSION, myCertHash(this))) {
  45.             Toast.makeText(this, "In-house-defined signature permission is not defined by In house application.", Toast.LENGTH_LONG).show();
  46.             return;
  47.         }
  48.         // *** POINT 9 *** Verify if the destination application is an in-house application.
  49.         if (!PkgCert.test(this, TARGET_PACKAGE, myCertHash(this))) {
  50.             Toast.makeText(this, "Requested (Destination) application is not in-house application.", Toast.LENGTH_LONG).show();
  51.             return;
  52.         }
  53.         // *** POINT 10 *** Use an explicit intent when the destination component is an activity.
  54.         try {
  55.             Intent intent = new Intent();
  56.             intent.setClassName(TARGET_PACKAGE, TARGET_ACTIVITY);
  57.             startActivity(intent);
  58.         } catch(Exception e) {
  59.             Toast.makeText(this,
  60.             String.format("Exception occurs:%s", e.getMessage()), Toast.LENGTH_LONG).show();
  61.         }
  62.     }
  63. }

PkgCertWhitelists.java

  1. package org.jssec.android.shared;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import android.content.Context;
  7. public class PkgCertWhitelists {
  9.     private Map<String, String> mWhitelists = new HashMap<String, String>();
  11.     public boolean add(String pkgname, String sha256) {
  12.         if (pkgname == null) return false;
  13.         if (sha256 == null) return false;
  14.         sha256 = sha256.replaceAll(" ", "");
  15.         if (sha256.length() != 64) return false; // SHA-256 -> 32 bytes -> 64 chars
  16.         sha256 = sha256.toUpperCase();
  17.         if (sha256.replaceAll("[0-9A-F]+", "").length() != 0) return false; // found non hex char
  18.         mWhitelists.put(pkgname, sha256);
  19.         return true;
  20.     }
  22.     public boolean test(Context ctx, String pkgname) {
  23.         // Get the correct hash value which corresponds to pkgname.
  24.         String correctHash = mWhitelists.get(pkgname);
  25.         // Compare the actual hash value of pkgname with the correct hash value.
  26.         return PkgCert.test(ctx, pkgname, correctHash);
  27.     }
  28. }

PkgCert.java

  1. package org.jssec.android.shared;
  3. import java.security.MessageDigest;
  4. import java.security.NoSuchAlgorithmException;
  5. import android.content.Context;
  6. import android.content.pm.PackageInfo;
  7. import android.content.pm.PackageManager;
  8. import android.content.pm.PackageManager.NameNotFoundException;
  9. import android.content.pm.Signature;
  11. public class PkgCert {
  13.     public static boolean test(Context ctx, String pkgname, String correctHash) {
  14.         if (correctHash == null) return false;
  15.         correctHash = correctHash.replaceAll(" ", "");
  16.         return correctHash.equals(hash(ctx, pkgname));
  17.     }
  19.     public static String hash(Context ctx, String pkgname) {
  20.         if (pkgname == null) return null;
  21.         try {
  22.             PackageManager pm = ctx.getPackageManager();
  23.             PackageInfo pkginfo = pm.getPackageInfo(pkgname, PackageManager.GET_SIGNATURES);
  24.             if (pkginfo.signatures.length != 1) return null; // Will not handle multiple signatures.
  25.             Signature sig = pkginfo.signatures[0];
  26.             byte[] cert = sig.toByteArray();
  27.             byte[] sha256 = computeSha256(cert);
  28.             return byte2hex(sha256);
  29.         } catch (NameNotFoundException e) {
  30.             return null;
  31.         }
  32.     }
  34.     private static byte[] computeSha256(byte[] data) {
  35.         try {
  36.             return MessageDigest.getInstance("SHA-256").digest(data);
  37.         } catch (NoSuchAlgorithmException e) {
  38.             return null;
  39.         }
  40.     }
  42.     private static String byte2hex(byte[] data) {
  43.         if (data == null) return null;
  44.         final StringBuilder hexadecimal = new StringBuilder();
  45.         for (final byte b : data) {
  46.             hexadecimal.append(String.format("%02X", b));
  47.         }
  48.         return hexadecimal.toString();
  49.     }
  50. }

要点 11：导出 APK 时，请使用与使用该组件的应用相同的开发人员密钥对 APK 进行签名。

5.2.1.md - 图4

5.2.1.3 如何验证应用证书的散列值

我们将说明，如何验证应用证书的散列值，他们在本指南中不同位置出现。 严格来说，散列值意味着“用于签署 APK 的开发人员密钥的公钥证书的 SHA256 散列值”。

如何使用 Keytool 进行验证

使用与 JDK 捆绑在一起的名为 keytool 的程序，你可以获取开发人员密钥的公钥证书的散列值（也称为证书指纹）。 由于散列算法的不同，存在各种散列方法，例如 MD5，SHA1 和 SHA256。 但是，考虑到加密字节长度的安全强度，本指南推荐使用 SHA256。 不幸的是， Android SDK 中使用的， JDK6 绑定的 keytool 不支持 SHA256 来计算哈希值。 因此，有必要使用 JDK7 绑定的 keytool。

通过 keytool 输出 Android 调试证书内容的示例

  1. > keytool -list -v -keystore < keystore file > -storepass < password >
  2. Type of keystore: JKS
  3. Keystore provider: SUN
  4. One entry is included in a keystore
  5. Other name: androiddebugkey
  6. Date of creation: 2012/01/11
  7. Entry type: PrivateKeyEntry
  8. Length of certificate chain: 1
  9. Certificate[1]:
  10. Owner: CN=Android Debug, O=Android, C=US
  11. Issuer: CN=Android Debug, O=Android, C=US
  12. Serial number: 4f0cef98
  13. Start date of validity period: Wed Jan 11 11:10:32 JST 2012 End date: Fri Jan 03 11:10:32 JST 2042
  14. Certificate fingerprint:
  15. MD5: 9E:89:53:18:06:B2:E3:AC:B4:24:CD:6A:56:BF:1E:A1
  16. SHA1: A8:1E:5D:E5:68:24:FD:F6:F1:ED:2F:C3:6E:0F:09:A3:07:F8:5C:0C
  17. SHA256: FB:75:E9:B9:2E:9E:6B:4D:AB:3F:94:B2:EC:A1:F0:33:09:74:D8:7A:CF:42:58:22:A2:56:85:1B:0F
  18. :85:C6:35
  19. Signatrue algorithm name: SHA1withRSA
  20. Version: 3
  21. *******************************************
  22. *******************************************

如何使用 JSSEC 证书散列值检查器进行验证

在不安装JDK7的情况下，你可以使用 JSSEC 证书散列值检查器，轻松验证证书散列值。

5.2.1.md - 图5

这是一个 Android 应用，显示安装在设备中的，应用的证书哈希值列表。 在上图中，sha-256右侧显示的 64 个字符的十六进制字符串是证书哈希值。 本指南附带的示例代码文件夹JSSEC CertHash Checker是一组源代码。 如果你愿意，你可以编译代码并使用它。

5.2.1.4 Android 6.0 及更高版本中使用危险权限的方法

Android 6.0（API Level 23）结合了修改后的规范，与应用实现相关 - 特别是应用被授予权限的时间。

在 Android 5.1（API 级别 22）和更早版本的权限模型下（请参阅“5.2.3.6 Android 6.0 和更高版本中的权限模型规范修改”一节），安装时授予应用申请的所有权限 。 但是，在 Android 6.0 及更高版本中，应用开发人员必须以这样的方式实现应用，即对于危险权限，应用在适当的时候请求权限。 当应用请求权限时，Android OS 会向用户显示如下所示的确认窗口，请求用户决定，是否授予相关权限。 如果用户允许使用权限，则应用可以执行任何需要该权限的操作。

5.2.1.md - 图6

该规范还修改了权限授予的单位。 以前，所有权限都是同时授予的；在 Android 6.0（API Level 23）及更高版本中，权限是单独授予的（按权限组）。 结合这种修改，用户现在可以看到每个权限的单独确认窗口，允许用户在授予权限或拒绝权限时，作出更灵活的决定。 应用开发人员必须重新审视其应用的规格和设计，并充分考虑到权限被拒绝的可能性。

Android 6.0 及更高版本中的权限模型的详细信息，请参见“5.2.3.6 Android 6.0 和更高版本中的权限模型规范修改”部分。

要点：

  1. 应用声明他们将使用的权限

  2. 不要声明不必要的权限

  3. 检查是否应用被授予了权限

  4. 请求权限（打开一个对话框来向用户请求权限）

  5. 对拒绝使用权限的情况实现适当的行为

AndroidManifest.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="org.jssec.android.permission.permissionrequestingpermissionatruntime" >
  4.     <!-- *** POINT 1 *** Apps declare the Permissions they will use -->
  5.     <!-- Permission to read information on contacts (Protection Level: dangerous) -->
  6.     <uses-permission android:name="android.permission.READ_CONTACTS" />
  7.     <!-- *** POINT 2 *** Do not declare the use of unnecessary Permissions -->
  8.     <application
  9.         android:allowBackup="true"
  10.         android:icon="@mipmap/ic_launcher"
  11.         android:label="@string/app_name"
  12.         android:supportsRtl="true"
  13.         android:theme="@style/AppTheme" >
  14.         <activity
  15.             android:name=".MainActivity"
  16.             android:exported="true">
  17.             <intent-filter>
  18.             <action android:name="android.intent.action.MAIN" />
  19.                 <category android:name="android.intent.category.LAUNCHER" />
  20.             </intent-filter>
  21.         </activity>
  22.         <activity
  23.             android:name=".ContactListActivity"
  24.             android:exported="false">
  25.         </activity>
  26.     </application>
  27. </manifest>

MainActivity.java

  1. package org.jssec.android.permission.permissionrequestingpermissionatruntime;
  3. import android.Manifest;
  4. import android.content.Intent;
  5. import android.content.pm.PackageManager;
  6. import android.os.Bundle;
  7. import android.support.v4.app.ActivityCompat;
  8. import android.support.v4.content.ContextCompat;
  9. import android.support.v7.app.AppCompatActivity;
  10. import android.view.View;
  11. import android.widget.Button;
  12. import android.widget.Toast;
  14. public class MainActivity extends AppCompatActivity implements View.OnClickListener {
  16.     private static final int REQUEST_CODE_READ_CONTACTS = 0;
  18.     @Override
  19.     protected void onCreate(Bundle savedInstanceState) {
  20.         super.onCreate(savedInstanceState);
  21.         setContentView(R.layout.activity_main);
  22.         Button button = (Button)findViewById(R.id.button);
  23.         button.setOnClickListener(this);
  24.     }
  26.     @Override
  27.     public void onClick(View v) {
  28.         readContacts();
  29.     }
  31.     private void readContacts() {
  32.         // *** POINT 3 *** Check whether or not Permissions have been granted to the app
  33.         if (ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.READ_CONTACTS) != PackageManager.PERMISSION_GRANTED) {
  34.             // Permission was not granted
  35.             // *** POINT 4 *** Request Permissions (open a dialog to request permission from users)
  36.             ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_CONTACTS}, REQUEST_CODE_READ_CONTACTS);
  37.         } else {
  38.             // Permission was previously granted
  39.             showContactList();
  40.         }
  41.     }
  43.     // A callback method that receives the result of the user's selection
  44.     @Override
  45.     public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
  46.         switch (requestCode) {
  47.             case REQUEST_CODE_READ_CONTACTS:
  48.                 if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  49.                     // Permissions were granted; we may execute operations that use contact information
  50.                     showContactList();
  51.                 } else {
  52.                     // Because the Permission was denied, we may not execute operations that use contact information
  53.                     // *** POINT 5 *** Implement appropriate behavior for cases in which the use of a Permission is refused
  54.                     Toast.makeText(this, String.format("Use of contact is not allowed."), Toast.LENGTH_LONG).show();
  55.                 }
  56.             return;
  57.         }
  58.     }
  60.     // Show contact list
  61.     private void showContactList() {
  62.         // Launch ContactListActivity
  63.         Intent intent = new Intent();
  64.         intent.setClass(getApplicationContext(), ContactListActivity.class);
  65.         startActivity(intent);
  66.     }
  67. }