core/java/android/provider/FontsContract.java

   1 /*
   2  * Copyright (C) 2017 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 package android.provider;
  17
  18 import static java.lang.annotation.RetentionPolicy.SOURCE;
  19
  20 import android.annotation.IntDef;
  21 import android.annotation.IntRange;
  22 import android.annotation.NonNull;
  23 import android.annotation.Nullable;
  24 import android.content.ContentResolver;
  25 import android.content.ContentUris;
  26 import android.content.Context;
  27 import android.content.pm.PackageInfo;
  28 import android.content.pm.PackageManager.NameNotFoundException;
  29 import android.content.pm.PackageManager;
  30 import android.content.pm.ProviderInfo;
  31 import android.content.pm.Signature;
  32 import android.database.Cursor;
  33 import android.graphics.Typeface;
  34 import android.graphics.fonts.FontVariationAxis;
  35 import android.net.Uri;
  36 import android.os.Bundle;
  37 import android.os.CancellationSignal;
  38 import android.os.Handler;
  39 import android.os.HandlerThread;
  40 import android.os.ParcelFileDescriptor;
  41 import android.os.Process;
  42 import android.os.ResultReceiver;
  43 import android.util.ArraySet;
  44 import android.util.Log;
  45 import android.util.LruCache;
  46
  47 import com.android.internal.annotations.GuardedBy;
  48 import com.android.internal.annotations.VisibleForTesting;
  49 import com.android.internal.util.Preconditions;
  50
  51 import java.io.FileInputStream;
  52 import java.io.FileNotFoundException;
  53 import java.io.IOException;
  54 import java.lang.annotation.Retention;
  55 import java.lang.annotation.RetentionPolicy;
  56 import java.nio.ByteBuffer;
  57 import java.nio.channels.FileChannel;
  58 import java.util.ArrayList;
  59 import java.util.Arrays;
  60 import java.util.Collections;
  61 import java.util.Comparator;
  62 import java.util.HashMap;
  63 import java.util.List;
  64 import java.util.Map;
  65 import java.util.Set;
  66 import java.util.concurrent.TimeUnit;
  67 import java.util.concurrent.locks.Condition;
  68 import java.util.concurrent.locks.Lock;
  69 import java.util.concurrent.locks.ReentrantLock;
  70 import java.util.concurrent.atomic.AtomicBoolean;
  71 import java.util.concurrent.atomic.AtomicReference;
  72
  73 /**
  74  * Utility class to deal with Font ContentProviders.
  75  */
  76 public class FontsContract {
  77     private static final String TAG = "FontsContract";
  78
  79     /**
  80      * Defines the constants used in a response from a Font Provider. The cursor returned from the
  81      * query should have the ID column populated with the content uri ID for the resulting font.
  82      * This should point to a real file or shared memory, as the client will mmap the given file
  83      * descriptor. Pipes, sockets and other non-mmap-able file descriptors will fail to load in the
  84      * client application.
  85      */
  86     public static final class Columns implements BaseColumns {
  87
  88         // Do not instantiate.
  89         private Columns() {}
  90
  91         /**
  92          * Constant used to request data from a font provider. The cursor returned from the query
  93          * may populate this column with a long for the font file ID. The client will request a file
  94          * descriptor to "file/FILE_ID" with this ID immediately under the top-level content URI. If
  95          * not present, the client will request a file descriptor to the top-level URI with the
  96          * given base font ID. Note that several results may return the same file ID, e.g. for TTC
  97          * files with different indices.
  98          */
  99         public static final String FILE_ID = "file_id";
 100         /**
 101          * Constant used to request data from a font provider. The cursor returned from the query
 102          * should have this column populated with an int for the ttc index for the resulting font.
 103          */
 104         public static final String TTC_INDEX = "font_ttc_index";
 105         /**
 106          * Constant used to request data from a font provider. The cursor returned from the query
 107          * may populate this column with the font variation settings String information for the
 108          * font.
 109          */
 110         public static final String VARIATION_SETTINGS = "font_variation_settings";
 111         /**
 112          * Constant used to request data from a font provider. The cursor returned from the query
 113          * should have this column populated with the int weight for the resulting font. This value
 114          * should be between 100 and 900. The most common values are 400 for regular weight and 700
 115          * for bold weight.
 116          */
 117         public static final String WEIGHT = "font_weight";
 118         /**
 119          * Constant used to request data from a font provider. The cursor returned from the query
 120          * should have this column populated with the int italic for the resulting font. This should
 121          * be 0 for regular style and 1 for italic.
 122          */
 123         public static final String ITALIC = "font_italic";
 124         /**
 125          * Constant used to request data from a font provider. The cursor returned from the query
 126          * should have this column populated to indicate the result status of the
 127          * query. This will be checked before any other data in the cursor. Possible values are
 128          * {@link #RESULT_CODE_OK}, {@link #RESULT_CODE_FONT_NOT_FOUND},
 129          * {@link #RESULT_CODE_MALFORMED_QUERY} and {@link #RESULT_CODE_FONT_UNAVAILABLE} for system
 130          * defined values. You may also define your own values in the 0x000010000..0xFFFF0000 range.
 131          * If not present, {@link #RESULT_CODE_OK} will be assumed.
 132          */
 133         public static final String RESULT_CODE = "result_code";
 134
 135         /**
 136          * Constant used to represent a result was retrieved successfully. The given fonts will be
 137          * attempted to retrieve immediately via
 138          * {@link android.content.ContentProvider#openFile(Uri, String)}. See {@link #RESULT_CODE}.
 139          */
 140         public static final int RESULT_CODE_OK = 0;
 141         /**
 142          * Constant used to represent a result was not found. See {@link #RESULT_CODE}.
 143          */
 144         public static final int RESULT_CODE_FONT_NOT_FOUND = 1;
 145         /**
 146          * Constant used to represent a result was found, but cannot be provided at this moment. Use
 147          * this to indicate, for example, that a font needs to be fetched from the network. See
 148          * {@link #RESULT_CODE}.
 149          */
 150         public static final int RESULT_CODE_FONT_UNAVAILABLE = 2;
 151         /**
 152          * Constant used to represent that the query was not in a supported format by the provider.
 153          * See {@link #RESULT_CODE}.
 154          */
 155         public static final int RESULT_CODE_MALFORMED_QUERY = 3;
 156     }
 157
 158     private static final Object sLock = new Object();
 159     @GuardedBy("sLock")
 160     private static Handler sHandler;
 161     @GuardedBy("sLock")
 162     private static HandlerThread sThread;
 163     @GuardedBy("sLock")
 164     private static Set<String> sInQueueSet;
 165
 166     private volatile static Context sContext;  // set once in setApplicationContextForResources
 167
 168     private static final LruCache<String, Typeface> sTypefaceCache = new LruCache<>(16);
 169
 170     private FontsContract() {
 171     }
 172
 173     /** @hide */
 174     public static void setApplicationContextForResources(Context context) {
 175         sContext = context.getApplicationContext();
 176     }
 177
 178     /**
 179      * Object represent a font entry in the family returned from {@link #fetchFonts}.
 180      */
 181     public static class FontInfo {
 182         private final Uri mUri;
 183         private final int mTtcIndex;
 184         private final FontVariationAxis[] mAxes;
 185         private final int mWeight;
 186         private final boolean mItalic;
 187         private final int mResultCode;
 188
 189         /**
 190          * Creates a Font with all the information needed about a provided font.
 191          * @param uri A URI associated to the font file.
 192          * @param ttcIndex If providing a TTC_INDEX file, the index to point to. Otherwise, 0.
 193          * @param axes If providing a variation font, the settings for it. May be null.
 194          * @param weight An integer that indicates the font weight.
 195          * @param italic A boolean that indicates the font is italic style or not.
 196          * @param resultCode A boolean that indicates the font contents is ready.
 197          */
 198         /** @hide */
 199         public FontInfo(@NonNull Uri uri, @IntRange(from = 0) int ttcIndex,
 200                 @Nullable FontVariationAxis[] axes, @IntRange(from = 1, to = 1000) int weight,
 201                 boolean italic, int resultCode) {
 202             mUri = Preconditions.checkNotNull(uri);
 203             mTtcIndex = ttcIndex;
 204             mAxes = axes;
 205             mWeight = weight;
 206             mItalic = italic;
 207             mResultCode = resultCode;
 208         }
 209
 210         /**
 211          * Returns a URI associated to this record.
 212          */
 213         public @NonNull Uri getUri() {
 214             return mUri;
 215         }
 216
 217         /**
 218          * Returns the index to be used to access this font when accessing a TTC file.
 219          */
 220         public @IntRange(from = 0) int getTtcIndex() {
 221             return mTtcIndex;
 222         }
 223
 224         /**
 225          * Returns the list of axes associated to this font.
 226          */
 227         public @Nullable FontVariationAxis[] getAxes() {
 228             return mAxes;
 229         }
 230
 231         /**
 232          * Returns the weight value for this font.
 233          */
 234         public @IntRange(from = 1, to = 1000) int getWeight() {
 235             return mWeight;
 236         }
 237
 238         /**
 239          * Returns whether this font is italic.
 240          */
 241         public boolean isItalic() {
 242             return mItalic;
 243         }
 244
 245         /**
 246          * Returns result code.
 247          *
 248          * {@link FontsContract.Columns#RESULT_CODE}
 249          */
 250         public int getResultCode() {
 251             return mResultCode;
 252         }
 253     }
 254
 255     /**
 256      * Object returned from {@link #fetchFonts}.
 257      */
 258     public static class FontFamilyResult {
 259         /**
 260          * Constant represents that the font was successfully retrieved. Note that when this value
 261          * is set and {@link #getFonts} returns an empty array, it means there were no fonts
 262          * matching the given query.
 263          */
 264         public static final int STATUS_OK = 0;
 265
 266         /**
 267          * Constant represents that the given certificate was not matched with the provider's
 268          * signature. {@link #getFonts} returns null if this status was set.
 269          */
 270         public static final int STATUS_WRONG_CERTIFICATES = 1;
 271
 272         /**
 273          * Constant represents that the provider returns unexpected data. {@link #getFonts} returns
 274          * null if this status was set. For example, this value is set when the font provider
 275          * gives invalid format of variation settings.
 276          */
 277         public static final int STATUS_UNEXPECTED_DATA_PROVIDED = 2;
 278
 279         /**
 280          * Constant represents that the fetching font data was rejected by system. This happens if
 281          * the passed context is restricted.
 282          */
 283         public static final int STATUS_REJECTED = 3;
 284
 285         /** @hide */
 286         @IntDef({STATUS_OK, STATUS_WRONG_CERTIFICATES, STATUS_UNEXPECTED_DATA_PROVIDED})
 287         @Retention(RetentionPolicy.SOURCE)
 288         @interface FontResultStatus {}
 289
 290         private final @FontResultStatus int mStatusCode;
 291         private final FontInfo[] mFonts;
 292
 293         /** @hide */
 294         public FontFamilyResult(@FontResultStatus int statusCode, @Nullable FontInfo[] fonts) {
 295             mStatusCode = statusCode;
 296             mFonts = fonts;
 297         }
 298
 299         public @FontResultStatus int getStatusCode() {
 300             return mStatusCode;
 301         }
 302
 303         public @NonNull FontInfo[] getFonts() {
 304             return mFonts;
 305         }
 306     }
 307
 308     private static final int THREAD_RENEWAL_THRESHOLD_MS = 10000;
 309
 310     private static final long SYNC_FONT_FETCH_TIMEOUT_MS = 500;
 311
 312     // We use a background thread to post the content resolving work for all requests on. This
 313     // thread should be quit/stopped after all requests are done.
 314     // TODO: Factor out to other class. Consider to switch MessageQueue.IdleHandler.
 315     private static final Runnable sReplaceDispatcherThreadRunnable = new Runnable() {
 316         @Override
 317         public void run() {
 318             synchronized (sLock) {
 319                 if (sThread != null) {
 320                     sThread.quitSafely();
 321                     sThread = null;
 322                     sHandler = null;
 323                 }
 324             }
 325         }
 326     };
 327
 328     /** @hide */
 329     public static Typeface getFontSync(FontRequest request) {
 330         final String id = request.getIdentifier();
 331         Typeface cachedTypeface = sTypefaceCache.get(id);
 332         if (cachedTypeface != null) {
 333             return cachedTypeface;
 334         }
 335
 336         // Unfortunately the typeface is not available at this time, but requesting from the font
 337         // provider takes too much time. For now, request the font data to ensure it is in the cache
 338         // next time and return.
 339         synchronized (sLock) {
 340             if (sHandler == null) {
 341                 sThread = new HandlerThread("fonts", Process.THREAD_PRIORITY_BACKGROUND);
 342                 sThread.start();
 343                 sHandler = new Handler(sThread.getLooper());
 344             }
 345             final Lock lock = new ReentrantLock();
 346             final Condition cond = lock.newCondition();
 347             final AtomicReference<Typeface> holder = new AtomicReference<>();
 348             final AtomicBoolean waiting = new AtomicBoolean(true);
 349             final AtomicBoolean timeout = new AtomicBoolean(false);
 350
 351             sHandler.post(() -> {
 352                 try {
 353                     FontFamilyResult result = fetchFonts(sContext, null, request);
 354                     if (result.getStatusCode() == FontFamilyResult.STATUS_OK) {
 355                         Typeface typeface = buildTypeface(sContext, null, result.getFonts());
 356                         if (typeface != null) {
 357                             sTypefaceCache.put(id, typeface);
 358                         }
 359                         holder.set(typeface);
 360                     }
 361                 } catch (NameNotFoundException e) {
 362                     // Ignore.
 363                 }
 364                 lock.lock();
 365                 try {
 366                     if (!timeout.get()) {
 367                       waiting.set(false);
 368                       cond.signal();
 369                     }
 370                 } finally {
 371                     lock.unlock();
 372                 }
 373             });
 374             sHandler.removeCallbacks(sReplaceDispatcherThreadRunnable);
 375             sHandler.postDelayed(sReplaceDispatcherThreadRunnable, THREAD_RENEWAL_THRESHOLD_MS);
 376
 377             long remaining = TimeUnit.MILLISECONDS.toNanos(SYNC_FONT_FETCH_TIMEOUT_MS);
 378             lock.lock();
 379             try {
 380                 if (!waiting.get()) {
 381                     return holder.get();
 382                 }
 383                 for (;;) {
 384                     try {
 385                         remaining = cond.awaitNanos(remaining);
 386                     } catch (InterruptedException e) {
 387                         // do nothing.
 388                     }
 389                     if (!waiting.get()) {
 390                         return holder.get();
 391                     }
 392                     if (remaining <= 0) {
 393                         timeout.set(true);
 394                         Log.w(TAG, "Remote font fetch timed out: " +
 395                                 request.getProviderAuthority() + "/" + request.getQuery());
 396                         return null;
 397                     }
 398                 }
 399             } finally {
 400                 lock.unlock();
 401             }
 402         }
 403     }
 404
 405     /**
 406      * Interface used to receive asynchronously fetched typefaces.
 407      */
 408     public static class FontRequestCallback {
 409         /**
 410          * Constant returned by {@link #onTypefaceRequestFailed(int)} signaling that the given
 411          * provider was not found on the device.
 412          */
 413         public static final int FAIL_REASON_PROVIDER_NOT_FOUND = -1;
 414         /**
 415          * Constant returned by {@link #onTypefaceRequestFailed(int)} signaling that the given
 416          * provider must be authenticated and the given certificates do not match its signature.
 417          */
 418         public static final int FAIL_REASON_WRONG_CERTIFICATES = -2;
 419         /**
 420          * Constant returned by {@link #onTypefaceRequestFailed(int)} signaling that the font
 421          * returned by the provider was not loaded properly.
 422          */
 423         public static final int FAIL_REASON_FONT_LOAD_ERROR = -3;
 424         /**
 425          * Constant returned by {@link #onTypefaceRequestFailed(int)} signaling that the font
 426          * provider did not return any results for the given query.
 427          */
 428         public static final int FAIL_REASON_FONT_NOT_FOUND = Columns.RESULT_CODE_FONT_NOT_FOUND;
 429         /**
 430          * Constant returned by {@link #onTypefaceRequestFailed(int)} signaling that the font
 431          * provider found the queried font, but it is currently unavailable.
 432          */
 433         public static final int FAIL_REASON_FONT_UNAVAILABLE = Columns.RESULT_CODE_FONT_UNAVAILABLE;
 434         /**
 435          * Constant returned by {@link #onTypefaceRequestFailed(int)} signaling that the given
 436          * query was not supported by the provider.
 437          */
 438         public static final int FAIL_REASON_MALFORMED_QUERY = Columns.RESULT_CODE_MALFORMED_QUERY;
 439
 440         /** @hide */
 441         @IntDef({ FAIL_REASON_PROVIDER_NOT_FOUND, FAIL_REASON_FONT_LOAD_ERROR,
 442                 FAIL_REASON_FONT_NOT_FOUND, FAIL_REASON_FONT_UNAVAILABLE,
 443                 FAIL_REASON_MALFORMED_QUERY })
 444         @Retention(RetentionPolicy.SOURCE)
 445         @interface FontRequestFailReason {}
 446
 447         public FontRequestCallback() {}
 448
 449         /**
 450          * Called then a Typeface request done via {@link #requestFont} is complete. Note that this
 451          * method will not be called if {@link #onTypefaceRequestFailed(int)} is called instead.
 452          * @param typeface  The Typeface object retrieved.
 453          */
 454         public void onTypefaceRetrieved(Typeface typeface) {}
 455
 456         /**
 457          * Called when a Typeface request done via {@link #requestFont}} fails.
 458          * @param reason One of {@link #FAIL_REASON_PROVIDER_NOT_FOUND},
 459          *               {@link #FAIL_REASON_FONT_NOT_FOUND},
 460          *               {@link #FAIL_REASON_FONT_LOAD_ERROR},
 461          *               {@link #FAIL_REASON_FONT_UNAVAILABLE} or
 462          *               {@link #FAIL_REASON_MALFORMED_QUERY} if returned by the system. May also be
 463          *               a positive value greater than 0 defined by the font provider as an
 464          *               additional error code. Refer to the provider's documentation for more
 465          *               information on possible returned error codes.
 466          */
 467         public void onTypefaceRequestFailed(@FontRequestFailReason int reason) {}
 468     }
 469
 470     /**
 471      * Create a typeface object given a font request. The font will be asynchronously fetched,
 472      * therefore the result is delivered to the given callback. See {@link FontRequest}.
 473      * Only one of the methods in callback will be invoked, depending on whether the request
 474      * succeeds or fails. These calls will happen on the caller thread.
 475      *
 476      * Note that the result Typeface may be cached internally and the same instance will be returned
 477      * the next time you call this method with the same request. If you want to bypass this cache,
 478      * use {@link #fetchFonts} and {@link #buildTypeface} instead.
 479      *
 480      * @param context A context to be used for fetching from font provider.
 481      * @param request A {@link FontRequest} object that identifies the provider and query for the
 482      *                request. May not be null.
 483      * @param handler A handler to be processed the font fetching.
 484      * @param cancellationSignal A signal to cancel the operation in progress, or null if none. If
 485      *                           the operation is canceled, then {@link
 486      *                           android.os.OperationCanceledException} will be thrown.
 487      * @param callback A callback that will be triggered when results are obtained. May not be null.
 488      */
 489     public static void requestFonts(@NonNull Context context, @NonNull FontRequest request,
 490             @NonNull Handler handler, @Nullable CancellationSignal cancellationSignal,
 491             @NonNull FontRequestCallback callback) {
 492
 493         final Handler callerThreadHandler = new Handler();
 494         final Typeface cachedTypeface = sTypefaceCache.get(request.getIdentifier());
 495         if (cachedTypeface != null) {
 496             callerThreadHandler.post(() -> callback.onTypefaceRetrieved(cachedTypeface));
 497             return;
 498         }
 499
 500         handler.post(() -> {
 501             FontFamilyResult result;
 502             try {
 503                 result = fetchFonts(context, cancellationSignal, request);
 504             } catch (NameNotFoundException e) {
 505                 callerThreadHandler.post(() -> callback.onTypefaceRequestFailed(
 506                         FontRequestCallback.FAIL_REASON_PROVIDER_NOT_FOUND));
 507                 return;
 508             }
 509
 510             // Same request might be dispatched during fetchFonts. Check the cache again.
 511             final Typeface anotherCachedTypeface = sTypefaceCache.get(request.getIdentifier());
 512             if (anotherCachedTypeface != null) {
 513                 callerThreadHandler.post(() -> callback.onTypefaceRetrieved(anotherCachedTypeface));
 514                 return;
 515             }
 516
 517             if (result.getStatusCode() != FontFamilyResult.STATUS_OK) {
 518                 switch (result.getStatusCode()) {
 519                     case FontFamilyResult.STATUS_WRONG_CERTIFICATES:
 520                         callerThreadHandler.post(() -> callback.onTypefaceRequestFailed(
 521                                 FontRequestCallback.FAIL_REASON_WRONG_CERTIFICATES));
 522                         return;
 523                     case FontFamilyResult.STATUS_UNEXPECTED_DATA_PROVIDED:
 524                         callerThreadHandler.post(() -> callback.onTypefaceRequestFailed(
 525                                 FontRequestCallback.FAIL_REASON_FONT_LOAD_ERROR));
 526                         return;
 527                     default:
 528                         // fetchFont returns unexpected status type. Fallback to load error.
 529                         callerThreadHandler.post(() -> callback.onTypefaceRequestFailed(
 530                                 FontRequestCallback.FAIL_REASON_FONT_LOAD_ERROR));
 531                         return;
 532                 }
 533             }
 534
 535             final FontInfo[] fonts = result.getFonts();
 536             if (fonts == null || fonts.length == 0) {
 537                 callerThreadHandler.post(() -> callback.onTypefaceRequestFailed(
 538                         FontRequestCallback.FAIL_REASON_FONT_NOT_FOUND));
 539                 return;
 540             }
 541             for (final FontInfo font : fonts) {
 542                 if (font.getResultCode() != Columns.RESULT_CODE_OK) {
 543                     // We proceed if all font entry is ready to use. Otherwise report the first
 544                     // error.
 545                     final int resultCode = font.getResultCode();
 546                     if (resultCode < 0) {
 547                         // Negative values are reserved for internal errors. Fallback to load error.
 548                         callerThreadHandler.post(() -> callback.onTypefaceRequestFailed(
 549                                 FontRequestCallback.FAIL_REASON_FONT_LOAD_ERROR));
 550                     } else {
 551                         callerThreadHandler.post(() -> callback.onTypefaceRequestFailed(
 552                                 resultCode));
 553                     }
 554                     return;
 555                 }
 556             }
 557
 558             final Typeface typeface = buildTypeface(context, cancellationSignal, fonts);
 559             if (typeface == null) {
 560                 // Something went wrong during reading font files. This happens if the given font
 561                 // file is an unsupported font type.
 562                 callerThreadHandler.post(() -> callback.onTypefaceRequestFailed(
 563                         FontRequestCallback.FAIL_REASON_FONT_LOAD_ERROR));
 564                 return;
 565             }
 566
 567             sTypefaceCache.put(request.getIdentifier(), typeface);
 568             callerThreadHandler.post(() -> callback.onTypefaceRetrieved(typeface));
 569         });
 570     }
 571
 572     /**
 573      * Fetch fonts given a font request.
 574      *
 575      * @param context A {@link Context} to be used for fetching fonts.
 576      * @param cancellationSignal A signal to cancel the operation in progress, or null if none. If
 577      *                           the operation is canceled, then {@link
 578      *                           android.os.OperationCanceledException} will be thrown when the
 579      *                           query is executed.
 580      * @param request A {@link FontRequest} object that identifies the provider and query for the
 581      *                request.
 582      *
 583      * @return {@link FontFamilyResult}
 584      *
 585      * @throws NameNotFoundException If requested package or authority was not found in system.
 586      */
 587     public static @NonNull FontFamilyResult fetchFonts(
 588             @NonNull Context context, @Nullable CancellationSignal cancellationSignal,
 589             @NonNull FontRequest request) throws NameNotFoundException {
 590         if (context.isRestricted()) {
 591             // TODO: Should we allow if the peer process is system or myself?
 592             return new FontFamilyResult(FontFamilyResult.STATUS_REJECTED, null);
 593         }
 594         ProviderInfo providerInfo = getProvider(context.getPackageManager(), request);
 595         if (providerInfo == null) {
 596             return new FontFamilyResult(FontFamilyResult.STATUS_WRONG_CERTIFICATES, null);
 597
 598         }
 599         try {
 600             FontInfo[] fonts = getFontFromProvider(
 601                     context, request, providerInfo.authority, cancellationSignal);
 602             return new FontFamilyResult(FontFamilyResult.STATUS_OK, fonts);
 603         } catch (IllegalArgumentException e) {
 604             return new FontFamilyResult(FontFamilyResult.STATUS_UNEXPECTED_DATA_PROVIDED, null);
 605         }
 606     }
 607
 608     /**
 609      * Build a Typeface from an array of {@link FontInfo}
 610      *
 611      * Results that are marked as not ready will be skipped.
 612      *
 613      * @param context A {@link Context} that will be used to fetch the font contents.
 614      * @param cancellationSignal A signal to cancel the operation in progress, or null if none. If
 615      *                           the operation is canceled, then {@link
 616      *                           android.os.OperationCanceledException} will be thrown.
 617      * @param fonts An array of {@link FontInfo} to be used to create a Typeface.
 618      * @return A Typeface object. Returns null if typeface creation fails.
 619      */
 620     public static Typeface buildTypeface(@NonNull Context context,
 621             @Nullable CancellationSignal cancellationSignal, @NonNull FontInfo[] fonts) {
 622         if (context.isRestricted()) {
 623             // TODO: Should we allow if the peer process is system or myself?
 624             return null;
 625         }
 626         final Map<Uri, ByteBuffer> uriBuffer =
 627                 prepareFontData(context, fonts, cancellationSignal);
 628         if (uriBuffer.isEmpty()) {
 629             return null;
 630         }
 631         return new Typeface.Builder(fonts, uriBuffer).build();
 632     }
 633
 634     /**
 635      * A helper function to create a mapping from {@link Uri} to {@link ByteBuffer}.
 636      *
 637      * Skip if the file contents is not ready to be read.
 638      *
 639      * @param context A {@link Context} to be used for resolving content URI in
 640      *                {@link FontInfo}.
 641      * @param fonts An array of {@link FontInfo}.
 642      * @return A map from {@link Uri} to {@link ByteBuffer}.
 643      */
 644     private static Map<Uri, ByteBuffer> prepareFontData(Context context, FontInfo[] fonts,
 645             CancellationSignal cancellationSignal) {
 646         final HashMap<Uri, ByteBuffer> out = new HashMap<>();
 647         final ContentResolver resolver = context.getContentResolver();
 648
 649         for (FontInfo font : fonts) {
 650             if (font.getResultCode() != Columns.RESULT_CODE_OK) {
 651                 continue;
 652             }
 653
 654             final Uri uri = font.getUri();
 655             if (out.containsKey(uri)) {
 656                 continue;
 657             }
 658
 659             ByteBuffer buffer = null;
 660             try (final ParcelFileDescriptor pfd =
 661                     resolver.openFileDescriptor(uri, "r", cancellationSignal)) {
 662                 if (pfd != null) {
 663                     try (final FileInputStream fis =
 664                             new FileInputStream(pfd.getFileDescriptor())) {
 665                         final FileChannel fileChannel = fis.getChannel();
 666                         final long size = fileChannel.size();
 667                         buffer = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, size);
 668                     } catch (IOException e) {
 669                         // ignore
 670                     }
 671                 }
 672             } catch (IOException e) {
 673                 // ignore
 674             }
 675
 676             // TODO: try other approach?, e.g. read all contents instead of mmap.
 677
 678             out.put(uri, buffer);
 679         }
 680         return Collections.unmodifiableMap(out);
 681     }
 682
 683     /** @hide */
 684     @VisibleForTesting
 685     public static @Nullable ProviderInfo getProvider(
 686             PackageManager packageManager, FontRequest request) throws NameNotFoundException {
 687         String providerAuthority = request.getProviderAuthority();
 688         ProviderInfo info = packageManager.resolveContentProvider(providerAuthority, 0);
 689         if (info == null) {
 690             throw new NameNotFoundException("No package found for authority: " + providerAuthority);
 691         }
 692
 693         if (!info.packageName.equals(request.getProviderPackage())) {
 694             throw new NameNotFoundException("Found content provider " + providerAuthority
 695                     + ", but package was not " + request.getProviderPackage());
 696         }
 697         // Trust system apps without signature checks
 698         if (info.applicationInfo.isSystemApp()) {
 699             return info;
 700         }
 701
 702         List<byte[]> signatures;
 703         PackageInfo packageInfo = packageManager.getPackageInfo(info.packageName,
 704                 PackageManager.GET_SIGNATURES);
 705         signatures = convertToByteArrayList(packageInfo.signatures);
 706         Collections.sort(signatures, sByteArrayComparator);
 707
 708         List<List<byte[]>> requestCertificatesList = request.getCertificates();
 709         for (int i = 0; i < requestCertificatesList.size(); ++i) {
 710             // Make a copy so we can sort it without modifying the incoming data.
 711             List<byte[]> requestSignatures = new ArrayList<>(requestCertificatesList.get(i));
 712             Collections.sort(requestSignatures, sByteArrayComparator);
 713             if (equalsByteArrayList(signatures, requestSignatures)) {
 714                 return info;
 715             }
 716         }
 717         return null;
 718     }
 719
 720     private static final Comparator<byte[]> sByteArrayComparator = (l, r) -> {
 721         if (l.length != r.length) {
 722             return l.length - r.length;
 723         }
 724         for (int i = 0; i < l.length; ++i) {
 725             if (l[i] != r[i]) {
 726                 return l[i] - r[i];
 727             }
 728         }
 729         return 0;
 730     };
 731
 732     private static boolean equalsByteArrayList(
 733             List<byte[]> signatures, List<byte[]> requestSignatures) {
 734         if (signatures.size() != requestSignatures.size()) {
 735             return false;
 736         }
 737         for (int i = 0; i < signatures.size(); ++i) {
 738             if (!Arrays.equals(signatures.get(i), requestSignatures.get(i))) {
 739                 return false;
 740             }
 741         }
 742         return true;
 743     }
 744
 745     private static List<byte[]> convertToByteArrayList(Signature[] signatures) {
 746         List<byte[]> shas = new ArrayList<>();
 747         for (int i = 0; i < signatures.length; ++i) {
 748             shas.add(signatures[i].toByteArray());
 749         }
 750         return shas;
 751     }
 752
 753     /** @hide */
 754     @VisibleForTesting
 755     public static @NonNull FontInfo[] getFontFromProvider(
 756             Context context, FontRequest request, String authority,
 757             CancellationSignal cancellationSignal) {
 758         ArrayList<FontInfo> result = new ArrayList<>();
 759         final Uri uri = new Uri.Builder().scheme(ContentResolver.SCHEME_CONTENT)
 760                 .authority(authority)
 761                 .build();
 762         final Uri fileBaseUri = new Uri.Builder().scheme(ContentResolver.SCHEME_CONTENT)
 763                 .authority(authority)
 764                 .appendPath("file")
 765                 .build();
 766         try (Cursor cursor = context.getContentResolver().query(uri, new String[] { Columns._ID,
 767                         Columns.FILE_ID, Columns.TTC_INDEX, Columns.VARIATION_SETTINGS,
 768                         Columns.WEIGHT, Columns.ITALIC, Columns.RESULT_CODE },
 769                 "query = ?", new String[] { request.getQuery() }, null, cancellationSignal);) {
 770             // TODO: Should we restrict the amount of fonts that can be returned?
 771             // TODO: Write documentation explaining that all results should be from the same family.
 772             if (cursor != null && cursor.getCount() > 0) {
 773                 final int resultCodeColumnIndex = cursor.getColumnIndex(Columns.RESULT_CODE);
 774                 result = new ArrayList<>();
 775                 final int idColumnIndex = cursor.getColumnIndexOrThrow(Columns._ID);
 776                 final int fileIdColumnIndex = cursor.getColumnIndex(Columns.FILE_ID);
 777                 final int ttcIndexColumnIndex = cursor.getColumnIndex(Columns.TTC_INDEX);
 778                 final int vsColumnIndex = cursor.getColumnIndex(Columns.VARIATION_SETTINGS);
 779                 final int weightColumnIndex = cursor.getColumnIndex(Columns.WEIGHT);
 780                 final int italicColumnIndex = cursor.getColumnIndex(Columns.ITALIC);
 781                 while (cursor.moveToNext()) {
 782                     int resultCode = resultCodeColumnIndex != -1
 783                             ? cursor.getInt(resultCodeColumnIndex) : Columns.RESULT_CODE_OK;
 784                     final int ttcIndex = ttcIndexColumnIndex != -1
 785                             ? cursor.getInt(ttcIndexColumnIndex) : 0;
 786                     final String variationSettings = vsColumnIndex != -1
 787                             ? cursor.getString(vsColumnIndex) : null;
 788
 789                     Uri fileUri;
 790                     if (fileIdColumnIndex == -1) {
 791                         long id = cursor.getLong(idColumnIndex);
 792                         fileUri = ContentUris.withAppendedId(uri, id);
 793                     } else {
 794                         long id = cursor.getLong(fileIdColumnIndex);
 795                         fileUri = ContentUris.withAppendedId(fileBaseUri, id);
 796                     }
 797                     int weight;
 798                     boolean italic;
 799                     if (weightColumnIndex != -1 && italicColumnIndex != -1) {
 800                         weight = cursor.getInt(weightColumnIndex);
 801                         italic = cursor.getInt(italicColumnIndex) == 1;
 802                     } else {
 803                         weight = Typeface.Builder.NORMAL_WEIGHT;
 804                         italic = false;
 805                     }
 806                     FontVariationAxis[] axes =
 807                             FontVariationAxis.fromFontVariationSettings(variationSettings);
 808                     result.add(new FontInfo(fileUri, ttcIndex, axes, weight, italic, resultCode));
 809                 }
 810             }
 811         }
 812         return result.toArray(new FontInfo[0]);
 813     }
 814 }