frameworks/base/services/java/com/android/server/AppWidgetService.java

   1 /*
   2  * Copyright (C) 2007 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 com.android.server;
  18
  19 import android.app.AlarmManager;
  20 import android.app.PendingIntent;
  21 import android.appwidget.AppWidgetManager;
  22 import android.appwidget.AppWidgetProviderInfo;
  23 import android.content.BroadcastReceiver;
  24 import android.content.ComponentName;
  25 import android.content.Context;
  26 import android.content.Intent;
  27 import android.content.IntentFilter;
  28 import android.content.pm.ActivityInfo;
  29 import android.content.pm.ApplicationInfo;
  30 import android.content.pm.PackageManager;
  31 import android.content.pm.PackageInfo;
  32 import android.content.pm.ResolveInfo;
  33 import android.content.res.Resources;
  34 import android.content.res.TypedArray;
  35 import android.content.res.XmlResourceParser;
  36 import android.net.Uri;
  37 import android.os.Binder;
  38 import android.os.Bundle;
  39 import android.os.Process;
  40 import android.os.RemoteException;
  41 import android.os.SystemClock;
  42 import android.util.AttributeSet;
  43 import android.util.Slog;
  44 import android.util.TypedValue;
  45 import android.util.Xml;
  46 import android.widget.RemoteViews;
  47
  48 import java.io.IOException;
  49 import java.io.File;
  50 import java.io.FileDescriptor;
  51 import java.io.FileInputStream;
  52 import java.io.FileOutputStream;
  53 import java.io.PrintWriter;
  54 import java.util.ArrayList;
  55 import java.util.List;
  56 import java.util.Locale;
  57 import java.util.HashMap;
  58 import java.util.HashSet;
  59
  60 import com.android.internal.appwidget.IAppWidgetService;
  61 import com.android.internal.appwidget.IAppWidgetHost;
  62 import com.android.internal.util.FastXmlSerializer;
  63
  64 import org.xmlpull.v1.XmlPullParser;
  65 import org.xmlpull.v1.XmlPullParserException;
  66 import org.xmlpull.v1.XmlSerializer;
  67
  68 class AppWidgetService extends IAppWidgetService.Stub
  69 {
  70     private static final String TAG = "AppWidgetService";
  71
  72     private static final String SETTINGS_FILENAME = "appwidgets.xml";
  73     private static final String SETTINGS_TMP_FILENAME = SETTINGS_FILENAME + ".tmp";
  74     private static final int MIN_UPDATE_PERIOD = 30 * 60 * 1000; // 30 minutes
  75
  76     /*
  77      * When identifying a Host or Provider based on the calling process, use the uid field.
  78      * When identifying a Host or Provider based on a package manager broadcast, use the
  79      * package given.
  80      */
  81
  82     static class Provider {
  83         int uid;
  84         AppWidgetProviderInfo info;
  85         ArrayList<AppWidgetId> instances = new ArrayList<AppWidgetId>();
  86         PendingIntent broadcast;
  87         boolean zombie; // if we're in safe mode, don't prune this just because nobody references it
  88
  89         int tag;    // for use while saving state (the index)
  90     }
  91
  92     static class Host {
  93         int uid;
  94         int hostId;
  95         String packageName;
  96         ArrayList<AppWidgetId> instances = new ArrayList<AppWidgetId>();
  97         IAppWidgetHost callbacks;
  98         boolean zombie; // if we're in safe mode, don't prune this just because nobody references it
  99
 100         int tag;    // for use while saving state (the index)
 101     }
 102
 103     static class AppWidgetId {
 104         int appWidgetId;
 105         Provider provider;
 106         RemoteViews views;
 107         Host host;
 108     }
 109
 110     Context mContext;
 111     Locale mLocale;
 112     PackageManager mPackageManager;
 113     AlarmManager mAlarmManager;
 114     ArrayList<Provider> mInstalledProviders = new ArrayList<Provider>();
 115     int mNextAppWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID + 1;
 116     final ArrayList<AppWidgetId> mAppWidgetIds = new ArrayList<AppWidgetId>();
 117     ArrayList<Host> mHosts = new ArrayList<Host>();
 118     boolean mSafeMode;
 119
 120     AppWidgetService(Context context) {
 121         mContext = context;
 122         mPackageManager = context.getPackageManager();
 123         mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE);
 124     }
 125
 126     public void systemReady(boolean safeMode) {
 127         mSafeMode = safeMode;
 128
 129         loadAppWidgetList();
 130         loadStateLocked();
 131
 132         // Register for the boot completed broadcast, so we can send the
 133         // ENABLE broacasts.  If we try to send them now, they time out,
 134         // because the system isn't ready to handle them yet.
 135         mContext.registerReceiver(mBroadcastReceiver,
 136                 new IntentFilter(Intent.ACTION_BOOT_COMPLETED), null, null);
 137
 138         // Register for configuration changes so we can update the names
 139         // of the widgets when the locale changes.
 140         mContext.registerReceiver(mBroadcastReceiver,
 141                 new IntentFilter(Intent.ACTION_CONFIGURATION_CHANGED), null, null);
 142
 143         // Register for broadcasts about package install, etc., so we can
 144         // update the provider list.
 145         IntentFilter filter = new IntentFilter();
 146         filter.addAction(Intent.ACTION_PACKAGE_ADDED);
 147         filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
 148         filter.addDataScheme("package");
 149         mContext.registerReceiver(mBroadcastReceiver, filter);
 150         // Register for events related to sdcard installation.
 151         IntentFilter sdFilter = new IntentFilter();
 152         sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE);
 153         sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
 154         mContext.registerReceiver(mBroadcastReceiver, sdFilter);
 155     }
 156
 157     @Override
 158     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
 159         if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
 160                 != PackageManager.PERMISSION_GRANTED) {
 161             pw.println("Permission Denial: can't dump from from pid="
 162                     + Binder.getCallingPid()
 163                     + ", uid=" + Binder.getCallingUid());
 164             return;
 165         }
 166
 167         synchronized (mAppWidgetIds) {
 168             int N = mInstalledProviders.size();
 169             pw.println("Providers:");
 170             for (int i=0; i<N; i++) {
 171                 Provider p = mInstalledProviders.get(i);
 172                 AppWidgetProviderInfo info = p.info;
 173                 pw.print("  ["); pw.print(i); pw.print("] provider ");
 174                         pw.print(info.provider.flattenToShortString());
 175                         pw.println(':');
 176                 pw.print("    min=("); pw.print(info.minWidth);
 177                         pw.print("x"); pw.print(info.minHeight);
 178                         pw.print(") updatePeriodMillis=");
 179                         pw.print(info.updatePeriodMillis);
 180                         pw.print(" initialLayout=#");
 181                         pw.print(Integer.toHexString(info.initialLayout));
 182                         pw.print(" zombie="); pw.println(p.zombie);
 183             }
 184
 185             N = mAppWidgetIds.size();
 186             pw.println(" ");
 187             pw.println("AppWidgetIds:");
 188             for (int i=0; i<N; i++) {
 189                 AppWidgetId id = mAppWidgetIds.get(i);
 190                 pw.print("  ["); pw.print(i); pw.print("] id=");
 191                         pw.println(id.appWidgetId);
 192                 pw.print("    hostId=");
 193                         pw.print(id.host.hostId); pw.print(' ');
 194                         pw.print(id.host.packageName); pw.print('/');
 195                         pw.println(id.host.uid);
 196                 if (id.provider != null) {
 197                     pw.print("    provider=");
 198                             pw.println(id.provider.info.provider.flattenToShortString());
 199                 }
 200                 if (id.host != null) {
 201                     pw.print("    host.callbacks="); pw.println(id.host.callbacks);
 202                 }
 203                 if (id.views != null) {
 204                     pw.print("    views="); pw.println(id.views);
 205                 }
 206             }
 207
 208             N = mHosts.size();
 209             pw.println(" ");
 210             pw.println("Hosts:");
 211             for (int i=0; i<N; i++) {
 212                 Host host = mHosts.get(i);
 213                 pw.print("  ["); pw.print(i); pw.print("] hostId=");
 214                         pw.print(host.hostId); pw.print(' ');
 215                         pw.print(host.packageName); pw.print('/');
 216                         pw.print(host.uid); pw.println(':');
 217                 pw.print("    callbacks="); pw.println(host.callbacks);
 218                 pw.print("    instances.size="); pw.print(host.instances.size());
 219                         pw.print(" zombie="); pw.println(host.zombie);
 220             }
 221         }
 222     }
 223
 224     public int allocateAppWidgetId(String packageName, int hostId) {
 225         int callingUid = enforceCallingUid(packageName);
 226         synchronized (mAppWidgetIds) {
 227             int appWidgetId = mNextAppWidgetId++;
 228
 229             Host host = lookupOrAddHostLocked(callingUid, packageName, hostId);
 230
 231             AppWidgetId id = new AppWidgetId();
 232             id.appWidgetId = appWidgetId;
 233             id.host = host;
 234
 235             host.instances.add(id);
 236             mAppWidgetIds.add(id);
 237
 238             saveStateLocked();
 239
 240             return appWidgetId;
 241         }
 242     }
 243
 244     public void deleteAppWidgetId(int appWidgetId) {
 245         synchronized (mAppWidgetIds) {
 246             AppWidgetId id = lookupAppWidgetIdLocked(appWidgetId);
 247             if (id != null) {
 248                 deleteAppWidgetLocked(id);
 249                 saveStateLocked();
 250             }
 251         }
 252     }
 253
 254     public void deleteHost(int hostId) {
 255         synchronized (mAppWidgetIds) {
 256             int callingUid = getCallingUid();
 257             Host host = lookupHostLocked(callingUid, hostId);
 258             if (host != null) {
 259                 deleteHostLocked(host);
 260                 saveStateLocked();
 261             }
 262         }
 263     }
 264
 265     public void deleteAllHosts() {
 266         synchronized (mAppWidgetIds) {
 267             int callingUid = getCallingUid();
 268             final int N = mHosts.size();
 269             boolean changed = false;
 270             for (int i=N-1; i>=0; i--) {
 271                 Host host = mHosts.get(i);
 272                 if (host.uid == callingUid) {
 273                     deleteHostLocked(host);
 274                     changed = true;
 275                 }
 276             }
 277             if (changed) {
 278                 saveStateLocked();
 279             }
 280         }
 281     }
 282
 283     void deleteHostLocked(Host host) {
 284         final int N = host.instances.size();
 285         for (int i=N-1; i>=0; i--) {
 286             AppWidgetId id = host.instances.get(i);
 287             deleteAppWidgetLocked(id);
 288         }
 289         host.instances.clear();
 290         mHosts.remove(host);
 291         // it's gone or going away, abruptly drop the callback connection
 292         host.callbacks = null;
 293     }
 294
 295     void deleteAppWidgetLocked(AppWidgetId id) {
 296         Host host = id.host;
 297         host.instances.remove(id);
 298         pruneHostLocked(host);
 299
 300         mAppWidgetIds.remove(id);
 301
 302         Provider p = id.provider;
 303         if (p != null) {
 304             p.instances.remove(id);
 305             if (!p.zombie) {
 306                 // send the broacast saying that this appWidgetId has been deleted
 307                 Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_DELETED);
 308                 intent.setComponent(p.info.provider);
 309                 intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, id.appWidgetId);
 310                 mContext.sendBroadcast(intent);
 311                 if (p.instances.size() == 0) {
 312                     // cancel the future updates
 313                     cancelBroadcasts(p);
 314
 315                     // send the broacast saying that the provider is not in use any more
 316                     intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_DISABLED);
 317                     intent.setComponent(p.info.provider);
 318                     mContext.sendBroadcast(intent);
 319                 }
 320             }
 321         }
 322     }
 323
 324     void cancelBroadcasts(Provider p) {
 325         if (p.broadcast != null) {
 326             mAlarmManager.cancel(p.broadcast);
 327             long token = Binder.clearCallingIdentity();
 328             try {
 329                 p.broadcast.cancel();
 330             } finally {
 331                 Binder.restoreCallingIdentity(token);
 332             }
 333             p.broadcast = null;
 334         }
 335     }
 336
 337     public void bindAppWidgetId(int appWidgetId, ComponentName provider) {
 338         mContext.enforceCallingPermission(android.Manifest.permission.BIND_APPWIDGET,
 339                 "bindGagetId appWidgetId=" + appWidgetId + " provider=" + provider);
 340         synchronized (mAppWidgetIds) {
 341             AppWidgetId id = lookupAppWidgetIdLocked(appWidgetId);
 342             if (id == null) {
 343                 throw new IllegalArgumentException("bad appWidgetId");
 344             }
 345             if (id.provider != null) {
 346                 throw new IllegalArgumentException("appWidgetId " + appWidgetId + " already bound to "
 347                         + id.provider.info.provider);
 348             }
 349             Provider p = lookupProviderLocked(provider);
 350             if (p == null) {
 351                 throw new IllegalArgumentException("not a appwidget provider: " + provider);
 352             }
 353             if (p.zombie) {
 354                 throw new IllegalArgumentException("can't bind to a 3rd party provider in"
 355                         + " safe mode: " + provider);
 356             }
 357
 358             id.provider = p;
 359             p.instances.add(id);
 360             int instancesSize = p.instances.size();
 361             if (instancesSize == 1) {
 362                 // tell the provider that it's ready
 363                 sendEnableIntentLocked(p);
 364             }
 365
 366             // send an update now -- We need this update now, and just for this appWidgetId.
 367             // It's less critical when the next one happens, so when we schdule the next one,
 368             // we add updatePeriodMillis to its start time.  That time will have some slop,
 369             // but that's okay.
 370             sendUpdateIntentLocked(p, new int[] { appWidgetId });
 371
 372             // schedule the future updates
 373             registerForBroadcastsLocked(p, getAppWidgetIds(p));
 374             saveStateLocked();
 375         }
 376     }
 377
 378     public AppWidgetProviderInfo getAppWidgetInfo(int appWidgetId) {
 379         synchronized (mAppWidgetIds) {
 380             AppWidgetId id = lookupAppWidgetIdLocked(appWidgetId);
 381             if (id != null && id.provider != null && !id.provider.zombie) {
 382                 return id.provider.info;
 383             }
 384             return null;
 385         }
 386     }
 387
 388     public RemoteViews getAppWidgetViews(int appWidgetId) {
 389         synchronized (mAppWidgetIds) {
 390             AppWidgetId id = lookupAppWidgetIdLocked(appWidgetId);
 391             if (id != null) {
 392                 return id.views;
 393             }
 394             return null;
 395         }
 396     }
 397
 398     public List<AppWidgetProviderInfo> getInstalledProviders() {
 399         synchronized (mAppWidgetIds) {
 400             final int N = mInstalledProviders.size();
 401             ArrayList<AppWidgetProviderInfo> result = new ArrayList<AppWidgetProviderInfo>(N);
 402             for (int i=0; i<N; i++) {
 403                 Provider p = mInstalledProviders.get(i);
 404                 if (!p.zombie) {
 405                     result.add(p.info);
 406                 }
 407             }
 408             return result;
 409         }
 410     }
 411
 412     public void updateAppWidgetIds(int[] appWidgetIds, RemoteViews views) {
 413         if (appWidgetIds == null) {
 414             return;
 415         }
 416         if (appWidgetIds.length == 0) {
 417             return;
 418         }
 419         final int N = appWidgetIds.length;
 420
 421         synchronized (mAppWidgetIds) {
 422             for (int i=0; i<N; i++) {
 423                 AppWidgetId id = lookupAppWidgetIdLocked(appWidgetIds[i]);
 424                 updateAppWidgetInstanceLocked(id, views);
 425             }
 426         }
 427     }
 428
 429     public void updateAppWidgetProvider(ComponentName provider, RemoteViews views) {
 430         synchronized (mAppWidgetIds) {
 431             Provider p = lookupProviderLocked(provider);
 432             if (p == null) {
 433                 Slog.w(TAG, "updateAppWidgetProvider: provider doesn't exist: " + provider);
 434                 return;
 435             }
 436             ArrayList<AppWidgetId> instances = p.instances;
 437             final int N = instances.size();
 438             for (int i=0; i<N; i++) {
 439                 AppWidgetId id = instances.get(i);
 440                 updateAppWidgetInstanceLocked(id, views);
 441             }
 442         }
 443     }
 444
 445     void updateAppWidgetInstanceLocked(AppWidgetId id, RemoteViews views) {
 446         // allow for stale appWidgetIds and other badness
 447         // lookup also checks that the calling process can access the appWidgetId
 448         // drop unbound appWidgetIds (shouldn't be possible under normal circumstances)
 449         if (id != null && id.provider != null && !id.provider.zombie && !id.host.zombie) {
 450             id.views = views;
 451
 452             // is anyone listening?
 453             if (id.host.callbacks != null) {
 454                 try {
 455                     // the lock is held, but this is a oneway call
 456                     id.host.callbacks.updateAppWidget(id.appWidgetId, views);
 457                 } catch (RemoteException e) {
 458                     // It failed; remove the callback. No need to prune because
 459                     // we know that this host is still referenced by this instance.
 460                     id.host.callbacks = null;
 461                 }
 462             }
 463         }
 464     }
 465
 466     public int[] startListening(IAppWidgetHost callbacks, String packageName, int hostId,
 467             List<RemoteViews> updatedViews) {
 468         int callingUid = enforceCallingUid(packageName);
 469         synchronized (mAppWidgetIds) {
 470             Host host = lookupOrAddHostLocked(callingUid, packageName, hostId);
 471             host.callbacks = callbacks;
 472
 473             updatedViews.clear();
 474
 475             ArrayList<AppWidgetId> instances = host.instances;
 476             int N = instances.size();
 477             int[] updatedIds = new int[N];
 478             for (int i=0; i<N; i++) {
 479                 AppWidgetId id = instances.get(i);
 480                 updatedIds[i] = id.appWidgetId;
 481                 updatedViews.add(id.views);
 482             }
 483             return updatedIds;
 484         }
 485     }
 486
 487     public void stopListening(int hostId) {
 488         synchronized (mAppWidgetIds) {
 489             Host host = lookupHostLocked(getCallingUid(), hostId);
 490             if (host != null) {
 491                 host.callbacks = null;
 492                 pruneHostLocked(host);
 493             }
 494         }
 495     }
 496
 497     boolean canAccessAppWidgetId(AppWidgetId id, int callingUid) {
 498         if (id.host.uid == callingUid) {
 499             // Apps hosting the AppWidget have access to it.
 500             return true;
 501         }
 502         if (id.provider != null && id.provider.uid == callingUid) {
 503             // Apps providing the AppWidget have access to it (if the appWidgetId has been bound)
 504             return true;
 505         }
 506         if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.BIND_APPWIDGET)
 507                 == PackageManager.PERMISSION_GRANTED) {
 508             // Apps that can bind have access to all appWidgetIds.
 509             return true;
 510         }
 511         // Nobody else can access it.
 512         return false;
 513     }
 514
 515    AppWidgetId lookupAppWidgetIdLocked(int appWidgetId) {
 516         int callingUid = getCallingUid();
 517         final int N = mAppWidgetIds.size();
 518         for (int i=0; i<N; i++) {
 519             AppWidgetId id = mAppWidgetIds.get(i);
 520             if (id.appWidgetId == appWidgetId && canAccessAppWidgetId(id, callingUid)) {
 521                 return id;
 522             }
 523         }
 524         return null;
 525     }
 526
 527     Provider lookupProviderLocked(ComponentName provider) {
 528         final String className = provider.getClassName();
 529         final int N = mInstalledProviders.size();
 530         for (int i=0; i<N; i++) {
 531             Provider p = mInstalledProviders.get(i);
 532             if (p.info.provider.equals(provider) || className.equals(p.info.oldName)) {
 533                 return p;
 534             }
 535         }
 536         return null;
 537     }
 538
 539     Host lookupHostLocked(int uid, int hostId) {
 540         final int N = mHosts.size();
 541         for (int i=0; i<N; i++) {
 542             Host h = mHosts.get(i);
 543             if (h.uid == uid && h.hostId == hostId) {
 544                 return h;
 545             }
 546         }
 547         return null;
 548     }
 549
 550     Host lookupOrAddHostLocked(int uid, String packageName, int hostId) {
 551         final int N = mHosts.size();
 552         for (int i=0; i<N; i++) {
 553             Host h = mHosts.get(i);
 554             if (h.hostId == hostId && h.packageName.equals(packageName)) {
 555                 return h;
 556             }
 557         }
 558         Host host = new Host();
 559         host.packageName = packageName;
 560         host.uid = uid;
 561         host.hostId = hostId;
 562         mHosts.add(host);
 563         return host;
 564     }
 565
 566     void pruneHostLocked(Host host) {
 567         if (host.instances.size() == 0 && host.callbacks == null) {
 568             mHosts.remove(host);
 569         }
 570     }
 571
 572     void loadAppWidgetList() {
 573         PackageManager pm = mPackageManager;
 574
 575         Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
 576         List<ResolveInfo> broadcastReceivers = pm.queryBroadcastReceivers(intent,
 577                 PackageManager.GET_META_DATA);
 578
 579         final int N = broadcastReceivers == null ? 0 : broadcastReceivers.size();
 580         for (int i=0; i<N; i++) {
 581             ResolveInfo ri = broadcastReceivers.get(i);
 582             addProviderLocked(ri);
 583         }
 584     }
 585
 586     boolean addProviderLocked(ResolveInfo ri) {
 587         Provider p = parseProviderInfoXml(new ComponentName(ri.activityInfo.packageName,
 588                     ri.activityInfo.name), ri);
 589         if (p != null) {
 590             mInstalledProviders.add(p);
 591             return true;
 592         } else {
 593             return false;
 594         }
 595     }
 596
 597     void removeProviderLocked(int index, Provider p) {
 598         int N = p.instances.size();
 599         for (int i=0; i<N; i++) {
 600             AppWidgetId id = p.instances.get(i);
 601             // Call back with empty RemoteViews
 602             updateAppWidgetInstanceLocked(id, null);
 603             // Stop telling the host about updates for this from now on
 604             cancelBroadcasts(p);
 605             // clear out references to this appWidgetId
 606             id.host.instances.remove(id);
 607             mAppWidgetIds.remove(id);
 608             id.provider = null;
 609             pruneHostLocked(id.host);
 610             id.host = null;
 611         }
 612         p.instances.clear();
 613         mInstalledProviders.remove(index);
 614         // no need to send the DISABLE broadcast, since the receiver is gone anyway
 615         cancelBroadcasts(p);
 616     }
 617
 618     void sendEnableIntentLocked(Provider p) {
 619         Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_ENABLED);
 620         intent.setComponent(p.info.provider);
 621         mContext.sendBroadcast(intent);
 622     }
 623
 624     void sendUpdateIntentLocked(Provider p, int[] appWidgetIds) {
 625         if (appWidgetIds != null && appWidgetIds.length > 0) {
 626             Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
 627             intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, appWidgetIds);
 628             intent.setComponent(p.info.provider);
 629             mContext.sendBroadcast(intent);
 630         }
 631     }
 632
 633     void registerForBroadcastsLocked(Provider p, int[] appWidgetIds) {
 634         if (p.info.updatePeriodMillis > 0) {
 635             // if this is the first instance, set the alarm.  otherwise,
 636             // rely on the fact that we've already set it and that
 637             // PendingIntent.getBroadcast will update the extras.
 638             boolean alreadyRegistered = p.broadcast != null;
 639             Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
 640             intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, appWidgetIds);
 641             intent.setComponent(p.info.provider);
 642             long token = Binder.clearCallingIdentity();
 643             try {
 644                 p.broadcast = PendingIntent.getBroadcast(mContext, 1, intent,
 645                         PendingIntent.FLAG_UPDATE_CURRENT);
 646             } finally {
 647                 Binder.restoreCallingIdentity(token);
 648             }
 649             if (!alreadyRegistered) {
 650                 long period = p.info.updatePeriodMillis;
 651                 if (period < MIN_UPDATE_PERIOD) {
 652                     period = MIN_UPDATE_PERIOD;
 653                 }
 654                 mAlarmManager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
 655                         SystemClock.elapsedRealtime() + period, period, p.broadcast);
 656             }
 657         }
 658     }
 659
 660     static int[] getAppWidgetIds(Provider p) {
 661         int instancesSize = p.instances.size();
 662         int appWidgetIds[] = new int[instancesSize];
 663         for (int i=0; i<instancesSize; i++) {
 664             appWidgetIds[i] = p.instances.get(i).appWidgetId;
 665         }
 666         return appWidgetIds;
 667     }
 668
 669     public int[] getAppWidgetIds(ComponentName provider) {
 670         synchronized (mAppWidgetIds) {
 671             Provider p = lookupProviderLocked(provider);
 672             if (p != null && getCallingUid() == p.uid) {
 673                 return getAppWidgetIds(p);
 674             } else {
 675                 return new int[0];
 676             }
 677         }
 678     }
 679
 680     private Provider parseProviderInfoXml(ComponentName component, ResolveInfo ri) {
 681         Provider p = null;
 682
 683         ActivityInfo activityInfo = ri.activityInfo;
 684         XmlResourceParser parser = null;
 685         try {
 686             parser = activityInfo.loadXmlMetaData(mPackageManager,
 687                     AppWidgetManager.META_DATA_APPWIDGET_PROVIDER);
 688             if (parser == null) {
 689                 Slog.w(TAG, "No " + AppWidgetManager.META_DATA_APPWIDGET_PROVIDER + " meta-data for "
 690                         + "AppWidget provider '" + component + '\'');
 691                 return null;
 692             }
 693
 694             AttributeSet attrs = Xml.asAttributeSet(parser);
 695
 696             int type;
 697             while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
 698                     && type != XmlPullParser.START_TAG) {
 699                 // drain whitespace, comments, etc.
 700             }
 701
 702             String nodeName = parser.getName();
 703             if (!"appwidget-provider".equals(nodeName)) {
 704                 Slog.w(TAG, "Meta-data does not start with appwidget-provider tag for"
 705                         + " AppWidget provider '" + component + '\'');
 706                 return null;
 707             }
 708
 709             p = new Provider();
 710             AppWidgetProviderInfo info = p.info = new AppWidgetProviderInfo();
 711             // If metaData was null, we would have returned earlier when getting
 712             // the parser No need to do the check here
 713             info.oldName = activityInfo.metaData.getString(
 714                     AppWidgetManager.META_DATA_APPWIDGET_OLD_NAME);
 715
 716             info.provider = component;
 717             p.uid = activityInfo.applicationInfo.uid;
 718
 719             Resources res = mPackageManager.getResourcesForApplication(
 720                     activityInfo.applicationInfo);
 721
 722             TypedArray sa = res.obtainAttributes(attrs,
 723                     com.android.internal.R.styleable.AppWidgetProviderInfo);
 724
 725             // These dimensions has to be resolved in the application's context.
 726             // We simply send back the raw complex data, which will be
 727             // converted to dp in {@link AppWidgetManager#getAppWidgetInfo}.
 728             TypedValue value = sa.peekValue(
 729                     com.android.internal.R.styleable.AppWidgetProviderInfo_minWidth);
 730             info.minWidth = value != null ? value.data : 0;
 731             value = sa.peekValue(com.android.internal.R.styleable.AppWidgetProviderInfo_minHeight);
 732             info.minHeight = value != null ? value.data : 0;
 733
 734             info.updatePeriodMillis = sa.getInt(
 735                     com.android.internal.R.styleable.AppWidgetProviderInfo_updatePeriodMillis, 0);
 736             info.initialLayout = sa.getResourceId(
 737                     com.android.internal.R.styleable.AppWidgetProviderInfo_initialLayout, 0);
 738             String className = sa.getString(
 739                     com.android.internal.R.styleable.AppWidgetProviderInfo_configure);
 740             if (className != null) {
 741                 info.configure = new ComponentName(component.getPackageName(), className);
 742             }
 743             info.label = activityInfo.loadLabel(mPackageManager).toString();
 744             info.icon = ri.getIconResource();
 745             sa.recycle();
 746         } catch (Exception e) {
 747             // Ok to catch Exception here, because anything going wrong because
 748             // of what a client process passes to us should not be fatal for the
 749             // system process.
 750             Slog.w(TAG, "XML parsing failed for AppWidget provider '" + component + '\'', e);
 751             return null;
 752         } finally {
 753             if (parser != null) parser.close();
 754         }
 755         return p;
 756     }
 757
 758     int getUidForPackage(String packageName) throws PackageManager.NameNotFoundException {
 759         PackageInfo pkgInfo = mPackageManager.getPackageInfo(packageName, 0);
 760         if (pkgInfo == null || pkgInfo.applicationInfo == null) {
 761             throw new PackageManager.NameNotFoundException();
 762         }
 763         return pkgInfo.applicationInfo.uid;
 764     }
 765
 766     int enforceCallingUid(String packageName) throws IllegalArgumentException {
 767         int callingUid = getCallingUid();
 768         int packageUid;
 769         try {
 770             packageUid = getUidForPackage(packageName);
 771         } catch (PackageManager.NameNotFoundException ex) {
 772             throw new IllegalArgumentException("packageName and uid don't match packageName="
 773                     + packageName);
 774         }
 775         if (callingUid != packageUid && Process.supportsProcesses()) {
 776             throw new IllegalArgumentException("packageName and uid don't match packageName="
 777                     + packageName);
 778         }
 779         return callingUid;
 780     }
 781
 782     void sendInitialBroadcasts() {
 783         synchronized (mAppWidgetIds) {
 784             final int N = mInstalledProviders.size();
 785             for (int i=0; i<N; i++) {
 786                 Provider p = mInstalledProviders.get(i);
 787                 if (p.instances.size() > 0) {
 788                     sendEnableIntentLocked(p);
 789                     int[] appWidgetIds = getAppWidgetIds(p);
 790                     sendUpdateIntentLocked(p, appWidgetIds);
 791                     registerForBroadcastsLocked(p, appWidgetIds);
 792                 }
 793             }
 794         }
 795     }
 796
 797     // only call from initialization -- it assumes that the data structures are all empty
 798     void loadStateLocked() {
 799         File temp = savedStateTempFile();
 800         File real = savedStateRealFile();
 801
 802         // prefer the real file.  If it doesn't exist, use the temp one, and then copy it to the
 803         // real one.  if there is both a real file and a temp one, assume that the temp one isn't
 804         // fully written and delete it.
 805         if (real.exists()) {
 806             readStateFromFileLocked(real);
 807             if (temp.exists()) {
 808                 //noinspection ResultOfMethodCallIgnored
 809                 temp.delete();
 810             }
 811         } else if (temp.exists()) {
 812             readStateFromFileLocked(temp);
 813             //noinspection ResultOfMethodCallIgnored
 814             temp.renameTo(real);
 815         }
 816     }
 817
 818     void saveStateLocked() {
 819         File temp = savedStateTempFile();
 820         File real = savedStateRealFile();
 821
 822         if (!real.exists()) {
 823             // If the real one doesn't exist, it's either because this is the first time
 824             // or because something went wrong while copying them.  In this case, we can't
 825             // trust anything that's in temp.  In order to have the loadState code not
 826             // use the temporary one until it's fully written, create an empty file
 827             // for real, which will we'll shortly delete.
 828             try {
 829                 //noinspection ResultOfMethodCallIgnored
 830                 real.createNewFile();
 831             } catch (IOException e) {
 832                 // Ignore
 833             }
 834         }
 835
 836         if (temp.exists()) {
 837             //noinspection ResultOfMethodCallIgnored
 838             temp.delete();
 839         }
 840
 841         if (!writeStateToFileLocked(temp)) {
 842             Slog.w(TAG, "Failed to persist new settings");
 843             return;
 844         }
 845
 846         //noinspection ResultOfMethodCallIgnored
 847         real.delete();
 848         //noinspection ResultOfMethodCallIgnored
 849         temp.renameTo(real);
 850     }
 851
 852     boolean writeStateToFileLocked(File file) {
 853         FileOutputStream stream = null;
 854         int N;
 855
 856         try {
 857             stream = new FileOutputStream(file, false);
 858             XmlSerializer out = new FastXmlSerializer();
 859             out.setOutput(stream, "utf-8");
 860             out.startDocument(null, true);
 861
 862
 863             out.startTag(null, "gs");
 864
 865             int providerIndex = 0;
 866             N = mInstalledProviders.size();
 867             for (int i=0; i<N; i++) {
 868                 Provider p = mInstalledProviders.get(i);
 869                 if (p.instances.size() > 0) {
 870                     out.startTag(null, "p");
 871                     out.attribute(null, "pkg", p.info.provider.getPackageName());
 872                     out.attribute(null, "cl", p.info.provider.getClassName());
 873                     out.endTag(null, "p");
 874                     p.tag = providerIndex;
 875                     providerIndex++;
 876                 }
 877             }
 878
 879             N = mHosts.size();
 880             for (int i=0; i<N; i++) {
 881                 Host host = mHosts.get(i);
 882                 out.startTag(null, "h");
 883                 out.attribute(null, "pkg", host.packageName);
 884                 out.attribute(null, "id", Integer.toHexString(host.hostId));
 885                 out.endTag(null, "h");
 886                 host.tag = i;
 887             }
 888
 889             N = mAppWidgetIds.size();
 890             for (int i=0; i<N; i++) {
 891                 AppWidgetId id = mAppWidgetIds.get(i);
 892                 out.startTag(null, "g");
 893                 out.attribute(null, "id", Integer.toHexString(id.appWidgetId));
 894                 out.attribute(null, "h", Integer.toHexString(id.host.tag));
 895                 if (id.provider != null) {
 896                     out.attribute(null, "p", Integer.toHexString(id.provider.tag));
 897                 }
 898                 out.endTag(null, "g");
 899             }
 900
 901             out.endTag(null, "gs");
 902
 903             out.endDocument();
 904             stream.close();
 905             return true;
 906         } catch (IOException e) {
 907             try {
 908                 if (stream != null) {
 909                     stream.close();
 910                 }
 911             } catch (IOException ex) {
 912                 // Ignore
 913             }
 914             if (file.exists()) {
 915                 //noinspection ResultOfMethodCallIgnored
 916                 file.delete();
 917             }
 918             return false;
 919         }
 920     }
 921
 922     void readStateFromFileLocked(File file) {
 923         FileInputStream stream = null;
 924
 925         boolean success = false;
 926
 927         try {
 928             stream = new FileInputStream(file);
 929             XmlPullParser parser = Xml.newPullParser();
 930             parser.setInput(stream, null);
 931
 932             int type;
 933             int providerIndex = 0;
 934             HashMap<Integer,Provider> loadedProviders = new HashMap<Integer, Provider>();
 935             do {
 936                 type = parser.next();
 937                 if (type == XmlPullParser.START_TAG) {
 938                     String tag = parser.getName();
 939                     if ("p".equals(tag)) {
 940                         // TODO: do we need to check that this package has the same signature
 941                         // as before?
 942                         String pkg = parser.getAttributeValue(null, "pkg");
 943                         String cl = parser.getAttributeValue(null, "cl");
 944
 945                         final PackageManager packageManager = mContext.getPackageManager();
 946                         try {
 947                             packageManager.getReceiverInfo(new ComponentName(pkg, cl), 0);
 948                         } catch (PackageManager.NameNotFoundException e) {
 949                             String[] pkgs = packageManager.currentToCanonicalPackageNames(
 950                                     new String[] { pkg });
 951                             pkg = pkgs[0];
 952                         }
 953
 954                         Provider p = lookupProviderLocked(new ComponentName(pkg, cl));
 955                         if (p == null && mSafeMode) {
 956                             // if we're in safe mode, make a temporary one
 957                             p = new Provider();
 958                             p.info = new AppWidgetProviderInfo();
 959                             p.info.provider = new ComponentName(pkg, cl);
 960                             p.zombie = true;
 961                             mInstalledProviders.add(p);
 962                         }
 963                         if (p != null) {
 964                             // if it wasn't uninstalled or something
 965                             loadedProviders.put(providerIndex, p);
 966                         }
 967                         providerIndex++;
 968                     }
 969                     else if ("h".equals(tag)) {
 970                         Host host = new Host();
 971
 972                         // TODO: do we need to check that this package has the same signature
 973                         // as before?
 974                         host.packageName = parser.getAttributeValue(null, "pkg");
 975                         try {
 976                             host.uid = getUidForPackage(host.packageName);
 977                         } catch (PackageManager.NameNotFoundException ex) {
 978                             host.zombie = true;
 979                         }
 980                         if (!host.zombie || mSafeMode) {
 981                             // In safe mode, we don't discard the hosts we don't recognize
 982                             // so that they're not pruned from our list.  Otherwise, we do.
 983                             host.hostId = Integer.parseInt(
 984                                     parser.getAttributeValue(null, "id"), 16);
 985                             mHosts.add(host);
 986                         }
 987                     }
 988                     else if ("g".equals(tag)) {
 989                         AppWidgetId id = new AppWidgetId();
 990                         id.appWidgetId = Integer.parseInt(parser.getAttributeValue(null, "id"), 16);
 991                         if (id.appWidgetId >= mNextAppWidgetId) {
 992                             mNextAppWidgetId = id.appWidgetId + 1;
 993                         }
 994
 995                         String providerString = parser.getAttributeValue(null, "p");
 996                         if (providerString != null) {
 997                             // there's no provider if it hasn't been bound yet.
 998                             // maybe we don't have to save this, but it brings the system
 999                             // to the state it was in.
1000                             int pIndex = Integer.parseInt(providerString, 16);
1001                             id.provider = loadedProviders.get(pIndex);
1002                             if (false) {
1003                                 Slog.d(TAG, "bound appWidgetId=" + id.appWidgetId + " to provider "
1004                                         + pIndex + " which is " + id.provider);
1005                             }
1006                             if (id.provider == null) {
1007                                 // This provider is gone.  We just let the host figure out
1008                                 // that this happened when it fails to load it.
1009                                 continue;
1010                             }
1011                         }
1012
1013                         int hIndex = Integer.parseInt(parser.getAttributeValue(null, "h"), 16);
1014                         id.host = mHosts.get(hIndex);
1015                         if (id.host == null) {
1016                             // This host is gone.
1017                             continue;
1018                         }
1019
1020                         if (id.provider != null) {
1021                             id.provider.instances.add(id);
1022                         }
1023                         id.host.instances.add(id);
1024                         mAppWidgetIds.add(id);
1025                     }
1026                 }
1027             } while (type != XmlPullParser.END_DOCUMENT);
1028             success = true;
1029         } catch (NullPointerException e) {
1030             Slog.w(TAG, "failed parsing " + file, e);
1031         } catch (NumberFormatException e) {
1032             Slog.w(TAG, "failed parsing " + file, e);
1033         } catch (XmlPullParserException e) {
1034             Slog.w(TAG, "failed parsing " + file, e);
1035         } catch (IOException e) {
1036             Slog.w(TAG, "failed parsing " + file, e);
1037         } catch (IndexOutOfBoundsException e) {
1038             Slog.w(TAG, "failed parsing " + file, e);
1039         }
1040         try {
1041             if (stream != null) {
1042                 stream.close();
1043             }
1044         } catch (IOException e) {
1045             // Ignore
1046         }
1047
1048         if (success) {
1049             // delete any hosts that didn't manage to get connected (should happen)
1050             // if it matters, they'll be reconnected.
1051             for (int i=mHosts.size()-1; i>=0; i--) {
1052                 pruneHostLocked(mHosts.get(i));
1053             }
1054         } else {
1055             // failed reading, clean up
1056             mAppWidgetIds.clear();
1057             mHosts.clear();
1058             final int N = mInstalledProviders.size();
1059             for (int i=0; i<N; i++) {
1060                 mInstalledProviders.get(i).instances.clear();
1061             }
1062         }
1063     }
1064
1065     File savedStateTempFile() {
1066         return new File("/data/system/" + SETTINGS_TMP_FILENAME);
1067         //return new File(mContext.getFilesDir(), SETTINGS_FILENAME);
1068     }
1069
1070     File savedStateRealFile() {
1071         return new File("/data/system/" + SETTINGS_FILENAME);
1072         //return new File(mContext.getFilesDir(), SETTINGS_TMP_FILENAME);
1073     }
1074
1075     BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
1076         public void onReceive(Context context, Intent intent) {
1077             String action = intent.getAction();
1078             //Slog.d(TAG, "received " + action);
1079             if (Intent.ACTION_BOOT_COMPLETED.equals(action)) {
1080                 sendInitialBroadcasts();
1081             } else if (Intent.ACTION_CONFIGURATION_CHANGED.equals(action)) {
1082                 Locale revised = Locale.getDefault();
1083                 if (revised == null || mLocale == null ||
1084                     !(revised.equals(mLocale))) {
1085                     mLocale = revised;
1086
1087                     synchronized (mAppWidgetIds) {
1088                         int N = mInstalledProviders.size();
1089                         for (int i=N-1; i>=0; i--) {
1090                             Provider p = mInstalledProviders.get(i);
1091                             String pkgName = p.info.provider.getPackageName();
1092                             updateProvidersForPackageLocked(pkgName);
1093                         }
1094                         saveStateLocked();
1095                     }
1096                 }
1097             } else {
1098                 boolean added = false;
1099                 String pkgList[] = null;
1100                 if (Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(action)) {
1101                     pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
1102                     added = true;
1103                 } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.equals(action)) {
1104                     pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
1105                     added = false;
1106                 } else  {
1107                     Uri uri = intent.getData();
1108                     if (uri == null) {
1109                         return;
1110                     }
1111                     String pkgName = uri.getSchemeSpecificPart();
1112                     if (pkgName == null) {
1113                         return;
1114                     }
1115                     pkgList = new String[] { pkgName };
1116                     added = Intent.ACTION_PACKAGE_ADDED.equals(action);
1117                 }
1118                 if (pkgList == null || pkgList.length == 0) {
1119                     return;
1120                 }
1121                 if (added) {
1122                     synchronized (mAppWidgetIds) {
1123                         Bundle extras = intent.getExtras();
1124                         if (extras != null && extras.getBoolean(Intent.EXTRA_REPLACING, false)) {
1125                             for (String pkgName : pkgList) {
1126                                 // The package was just upgraded
1127                                 updateProvidersForPackageLocked(pkgName);
1128                             }
1129                         } else {
1130                             // The package was just added
1131                             for (String pkgName : pkgList) {
1132                                 addProvidersForPackageLocked(pkgName);
1133                             }
1134                         }
1135                         saveStateLocked();
1136                     }
1137                 } else {
1138                     Bundle extras = intent.getExtras();
1139                     if (extras != null && extras.getBoolean(Intent.EXTRA_REPLACING, false)) {
1140                         // The package is being updated.  We'll receive a PACKAGE_ADDED shortly.
1141                     } else {
1142                         synchronized (mAppWidgetIds) {
1143                             for (String pkgName : pkgList) {
1144                                 removeProvidersForPackageLocked(pkgName);
1145                                 saveStateLocked();
1146                             }
1147                         }
1148                     }
1149                 }
1150             }
1151         }
1152     };
1153
1154     void addProvidersForPackageLocked(String pkgName) {
1155         Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
1156         intent.setPackage(pkgName);
1157         List<ResolveInfo> broadcastReceivers = mPackageManager.queryBroadcastReceivers(intent,
1158                 PackageManager.GET_META_DATA);
1159
1160         final int N = broadcastReceivers == null ? 0 : broadcastReceivers.size();
1161         for (int i=0; i<N; i++) {
1162             ResolveInfo ri = broadcastReceivers.get(i);
1163             ActivityInfo ai = ri.activityInfo;
1164             if ((ai.applicationInfo.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0) {
1165                 continue;
1166             }
1167             if (pkgName.equals(ai.packageName)) {
1168                 addProviderLocked(ri);
1169             }
1170         }
1171     }
1172
1173     void updateProvidersForPackageLocked(String pkgName) {
1174         HashSet<String> keep = new HashSet<String>();
1175         Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
1176         intent.setPackage(pkgName);
1177         List<ResolveInfo> broadcastReceivers = mPackageManager.queryBroadcastReceivers(intent,
1178                 PackageManager.GET_META_DATA);
1179
1180         // add the missing ones and collect which ones to keep
1181         int N = broadcastReceivers == null ? 0 : broadcastReceivers.size();
1182         for (int i=0; i<N; i++) {
1183             ResolveInfo ri = broadcastReceivers.get(i);
1184             ActivityInfo ai = ri.activityInfo;
1185             if ((ai.applicationInfo.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0) {
1186                 continue;
1187             }
1188             if (pkgName.equals(ai.packageName)) {
1189                 ComponentName component = new ComponentName(ai.packageName, ai.name);
1190                 Provider p = lookupProviderLocked(component);
1191                 if (p == null) {
1192                     if (addProviderLocked(ri)) {
1193                         keep.add(ai.name);
1194                     }
1195                 } else {
1196                     Provider parsed = parseProviderInfoXml(component, ri);
1197                     if (parsed != null) {
1198                         keep.add(ai.name);
1199                         // Use the new AppWidgetProviderInfo.
1200                         p.info = parsed.info;
1201                         // If it's enabled
1202                         final int M = p.instances.size();
1203                         if (M > 0) {
1204                             int[] appWidgetIds = getAppWidgetIds(p);
1205                             // Reschedule for the new updatePeriodMillis (don't worry about handling
1206                             // it specially if updatePeriodMillis didn't change because we just sent
1207                             // an update, and the next one will be updatePeriodMillis from now).
1208                             cancelBroadcasts(p);
1209                             registerForBroadcastsLocked(p, appWidgetIds);
1210                             // If it's currently showing, call back with the new AppWidgetProviderInfo.
1211                             for (int j=0; j<M; j++) {
1212                                 AppWidgetId id = p.instances.get(j);
1213                                 id.views = null;
1214                                 if (id.host != null && id.host.callbacks != null) {
1215                                     try {
1216                                         id.host.callbacks.providerChanged(id.appWidgetId, p.info);
1217                                     } catch (RemoteException ex) {
1218                                         // It failed; remove the callback. No need to prune because
1219                                         // we know that this host is still referenced by this
1220                                         // instance.
1221                                         id.host.callbacks = null;
1222                                     }
1223                                 }
1224                             }
1225                             // Now that we've told the host, push out an update.
1226                             sendUpdateIntentLocked(p, appWidgetIds);
1227                         }
1228                     }
1229                 }
1230             }
1231         }
1232
1233         // prune the ones we don't want to keep
1234         N = mInstalledProviders.size();
1235         for (int i=N-1; i>=0; i--) {
1236             Provider p = mInstalledProviders.get(i);
1237             if (pkgName.equals(p.info.provider.getPackageName())
1238                     && !keep.contains(p.info.provider.getClassName())) {
1239                 removeProviderLocked(i, p);
1240             }
1241         }
1242     }
1243
1244     void removeProvidersForPackageLocked(String pkgName) {
1245         int N = mInstalledProviders.size();
1246         for (int i=N-1; i>=0; i--) {
1247             Provider p = mInstalledProviders.get(i);
1248             if (pkgName.equals(p.info.provider.getPackageName())) {
1249                 removeProviderLocked(i, p);
1250             }
1251         }
1252
1253         // Delete the hosts for this package too
1254         //
1255         // By now, we have removed any AppWidgets that were in any hosts here,
1256         // so we don't need to worry about sending DISABLE broadcasts to them.
1257         N = mHosts.size();
1258         for (int i=N-1; i>=0; i--) {
1259             Host host = mHosts.get(i);
1260             if (pkgName.equals(host.packageName)) {
1261                 deleteHostLocked(host);
1262             }
1263         }
1264     }
1265 }
1266