1 /* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.content.pm; 18 19 import android.os.Parcel; 20 import android.os.Parcelable; 21 import android.os.PatternMatcher; 22 import android.util.Printer; 23 24 /** 25 * Holds information about a specific 26 * {@link android.content.ContentProvider content provider}. This is returned by 27 * {@link android.content.pm.PackageManager#resolveContentProvider(java.lang.String, int) 28 * PackageManager.resolveContentProvider()}. 29 */ 30 public final class ProviderInfo extends ComponentInfo 31 implements Parcelable { 32 33 /** The name provider is published under content:// */ 34 public String authority = null; 35 36 /** Optional permission required for read-only access this content 37 * provider. */ 38 public String readPermission = null; 39 40 /** Optional permission required for read/write access this content 41 * provider. */ 42 public String writePermission = null; 43 44 /** If true, additional permissions to specific Uris in this content 45 * provider can be granted, as per the 46 * {@link android.R.styleable#AndroidManifestProvider_grantUriPermissions 47 * grantUriPermissions} attribute. 48 */ 49 public boolean grantUriPermissions = false; 50 51 /** If true, always apply URI permission grants, as per the 52 * {@link android.R.styleable#AndroidManifestProvider_forceUriPermissions 53 * forceUriPermissions} attribute. 54 */ 55 public boolean forceUriPermissions = false; 56 57 /** 58 * If non-null, these are the patterns that are allowed for granting URI 59 * permissions. Any URI that does not match one of these patterns will not 60 * allowed to be granted. If null, all URIs are allowed. The 61 * {@link PackageManager#GET_URI_PERMISSION_PATTERNS 62 * PackageManager.GET_URI_PERMISSION_PATTERNS} flag must be specified for 63 * this field to be filled in. 64 */ 65 public PatternMatcher[] uriPermissionPatterns = null; 66 67 /** 68 * If non-null, these are path-specific permissions that are allowed for 69 * accessing the provider. Any permissions listed here will allow a 70 * holding client to access the provider, and the provider will check 71 * the URI it provides when making calls against the patterns here. 72 */ 73 public PathPermission[] pathPermissions = null; 74 75 /** If true, this content provider allows multiple instances of itself 76 * to run in different process. If false, a single instances is always 77 * run in {@link #processName}. */ 78 public boolean multiprocess = false; 79 80 /** Used to control initialization order of single-process providers 81 * running in the same process. Higher goes first. */ 82 public int initOrder = 0; 83 84 /** 85 * Bit in {@link #flags} indicating if the provider is visible to ephemeral applications. 86 * @hide 87 */ 88 public static final int FLAG_VISIBLE_TO_INSTANT_APP = 0x100000; 89 90 /** 91 * Bit in {@link #flags}: If set, a single instance of the provider will 92 * run for all users on the device. Set from the 93 * {@link android.R.attr#singleUser} attribute. 94 */ 95 public static final int FLAG_SINGLE_USER = 0x40000000; 96 97 /** 98 * Options that have been set in the provider declaration in the 99 * manifest. 100 * These include: {@link #FLAG_SINGLE_USER}. 101 */ 102 public int flags = 0; 103 104 /** 105 * Whether or not this provider is syncable. 106 * @deprecated This flag is now being ignored. The current way to make a provider 107 * syncable is to provide a SyncAdapter service for a given provider/account type. 108 */ 109 @Deprecated 110 public boolean isSyncable = false; 111 ProviderInfo()112 public ProviderInfo() { 113 } 114 ProviderInfo(ProviderInfo orig)115 public ProviderInfo(ProviderInfo orig) { 116 super(orig); 117 authority = orig.authority; 118 readPermission = orig.readPermission; 119 writePermission = orig.writePermission; 120 grantUriPermissions = orig.grantUriPermissions; 121 forceUriPermissions = orig.forceUriPermissions; 122 uriPermissionPatterns = orig.uriPermissionPatterns; 123 pathPermissions = orig.pathPermissions; 124 multiprocess = orig.multiprocess; 125 initOrder = orig.initOrder; 126 flags = orig.flags; 127 isSyncable = orig.isSyncable; 128 } 129 dump(Printer pw, String prefix)130 public void dump(Printer pw, String prefix) { 131 dump(pw, prefix, DUMP_FLAG_ALL); 132 } 133 134 /** @hide */ dump(Printer pw, String prefix, int dumpFlags)135 public void dump(Printer pw, String prefix, int dumpFlags) { 136 super.dumpFront(pw, prefix); 137 pw.println(prefix + "authority=" + authority); 138 pw.println(prefix + "flags=0x" + Integer.toHexString(flags)); 139 super.dumpBack(pw, prefix, dumpFlags); 140 } 141 describeContents()142 public int describeContents() { 143 return 0; 144 } 145 writeToParcel(Parcel out, int parcelableFlags)146 @Override public void writeToParcel(Parcel out, int parcelableFlags) { 147 super.writeToParcel(out, parcelableFlags); 148 out.writeString(authority); 149 out.writeString(readPermission); 150 out.writeString(writePermission); 151 out.writeInt(grantUriPermissions ? 1 : 0); 152 out.writeInt(forceUriPermissions ? 1 : 0); 153 out.writeTypedArray(uriPermissionPatterns, parcelableFlags); 154 out.writeTypedArray(pathPermissions, parcelableFlags); 155 out.writeInt(multiprocess ? 1 : 0); 156 out.writeInt(initOrder); 157 out.writeInt(flags); 158 out.writeInt(isSyncable ? 1 : 0); 159 } 160 161 public static final @android.annotation.NonNull Parcelable.Creator<ProviderInfo> CREATOR 162 = new Parcelable.Creator<ProviderInfo>() { 163 public ProviderInfo createFromParcel(Parcel in) { 164 return new ProviderInfo(in); 165 } 166 167 public ProviderInfo[] newArray(int size) { 168 return new ProviderInfo[size]; 169 } 170 }; 171 toString()172 public String toString() { 173 return "ContentProviderInfo{name=" + authority + " className=" + name + "}"; 174 } 175 ProviderInfo(Parcel in)176 private ProviderInfo(Parcel in) { 177 super(in); 178 authority = in.readString(); 179 readPermission = in.readString(); 180 writePermission = in.readString(); 181 grantUriPermissions = in.readInt() != 0; 182 forceUriPermissions = in.readInt() != 0; 183 uriPermissionPatterns = in.createTypedArray(PatternMatcher.CREATOR); 184 pathPermissions = in.createTypedArray(PathPermission.CREATOR); 185 multiprocess = in.readInt() != 0; 186 initOrder = in.readInt(); 187 flags = in.readInt(); 188 isSyncable = in.readInt() != 0; 189 } 190 } 191