/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }
/** * In onCreate, we initialize our content provider on startup. This method is called for all * registered content providers on the application main thread at application launch time. * It must not perform lengthy operations, or application startup will be delayed. * * Nontrivial initialization (such as opening, upgrading, and scanning * databases) should be deferred until the content provider is used (via {@link #query}, * {@link #bulkInsert(Uri, ContentValues[])}, etc). * * Deferred initialization keeps application startup fast, avoids unnecessary work if the * provider turns out not to be needed, and stops database errors (such as a full disk) from * halting application launch. * * @return true if the provider was successfully loaded, false otherwise */ @Override public boolean onCreate() { /* * As noted in the comment above, onCreate is run on the main thread, so performing any * lengthy operations will cause lag in your app. Since WeatherDbHelper's constructor is * very lightweight, we are safe to perform that initialization here. */ mOpenHelper = new WeatherDbHelper(getContext()); return true; }