Removed ROOM inline compilation

app/src/main/java/androidx/room/package-info.java

@@ -1,129 +0,0 @@
-/*
- * Copyright (C) 2017 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Room is a Database Object Mapping library that makes it easy to access database on Android
- * applications.
- * <p>
- * Rather than hiding the details of SQLite, Room tries to embrace them by providing convenient APIs
- * to query the database and also verify such queries at compile time. This allows you to access
- * the full power of SQLite while having the type safety provided by Java SQL query builders.
- * <p>
- * There are 3 major components in Room.
- * <ul>
- *     <li>{@link androidx.room.Database Database}: This annotation marks a class as a database.
- *     It should be an abstract class that extends {@link androidx.room.RoomDatabase RoomDatabase}.
- *     At runtime, you can acquire an instance of it via {@link androidx.room.Room#databaseBuilder(
- *     android.content.Context,java.lang.Class, java.lang.String) Room.databaseBuilder} or
- *     {@link androidx.room.Room#inMemoryDatabaseBuilder(android.content.Context, java.lang.Class)
- *     Room.inMemoryDatabaseBuilder}.
- *     <p>
- *     The database class defines the list of entities and data access objects in the database.
- *     It is also the main access point for the underlying connection.
- *     </li>
- *     <li>{@link androidx.room.Entity Entity}: This annotation marks a class as a database row.
- *     For each {@link androidx.room.Entity Entity}, a database table is created to hold the items.
- *     The Entity class must be referenced in the
- *     {@link androidx.room.Database#entities() Database#entities} array. Each field of the Entity
- *     (and its super class) is persisted in the database unless it is denoted otherwise
- *     (see {@link androidx.room.Entity Entity} docs for details).
- *     </li>
- *     <li>{@link androidx.room.Dao Dao}: This annotation marks a class or interface as a
- *     Data Access Object. Data access objects are the main components of Room that are
- *     responsible for defining the methods that access the database. The class that is annotated
- *     with {@link androidx.room.Database Database} must have an abstract method that has 0
- *     arguments and returns the class that is annotated with Dao. While generating the code at
- *     compile time, Room will generate an implementation of this class.
- *     <p>
- *     Using Dao classes for database access rather than query builders or direct queries allows you
- *     to keep a separation between different components and easily mock the database access while
- *     testing your application.
- *     </li>
- * </ul>
- * Below is a sample of a simple database.
- * <pre>
- * // File: Song.java
- * {@literal @}Entity
- * public class User {
- *   {@literal @}PrimaryKey
- *   private int id;
- *   private String name;
- *   {@literal @}ColumnInfo(name = "release_year")
- *   private int releaseYear;
- *   // getters and setters are ignored for brevity but they are required for Room to work.
- * }
- * // File: SongDao.java
- * {@literal @}Dao
- * public interface SongDao {
- *   {@literal @}Query("SELECT * FROM song")
- *   List&lt;Song&gt; loadAll();
- *   {@literal @}Query("SELECT * FROM song WHERE id IN (:songIds)")
- *   List&lt;Song&gt; loadAllBySongId(int... songIds);
- *   {@literal @}Query("SELECT * FROM song WHERE name LIKE :name AND release_year = :year LIMIT 1")
- *   Song loadOneByNameAndReleaseYear(String first, int year);
- *   {@literal @}Insert
- *   void insertAll(Song... songs);
- *   {@literal @}Delete
- *   void delete(Song song);
- * }
- * // File: MusicDatabase.java
- * {@literal @}Database(entities = {Song.java})
- * public abstract class MusicDatabase extends RoomDatabase {
- *   public abstract SongDao userDao();
- * }
- * </pre>
- * You can create an instance of {@code MusicDatabase} as follows:
- * <pre>
- * MusicDatabase db = Room
- *     .databaseBuilder(getApplicationContext(), MusicDatabase.class, "database-name")
- *     .build();
- * </pre>
- * Since Room verifies your queries at compile time, it also detects information about which tables
- * are accessed by the query or what columns are present in the response.
- * <p>
- * You can observe a particular table for changes using the
- * {@link androidx.room.InvalidationTracker InvalidationTracker} class which you can acquire via
- * {@link androidx.room.RoomDatabase#getInvalidationTracker()
- * RoomDatabase.getInvalidationTracker}.
- * <p>
- * For convenience, Room allows you to return {@link androidx.lifecycle.LiveData LiveData} from
- * {@link androidx.room.Query Query} methods. It will automatically observe the related tables as
- * long as the {@code LiveData} has active observers.
- * <pre>
- * // This live data will automatically dispatch changes as the database changes.
- * {@literal @}Query("SELECT * FROM song ORDER BY name LIMIT 5")
- * LiveData&lt;Song&gt; loadFirstFiveSongs();
- * </pre>
- * <p>
- * You can also return arbitrary data objects from your query results as long as the fields in the
- * object match the list of columns in the query response. This makes it very easy to write
- * applications that drive the UI from persistent storage.
- * <pre>
- * class IdAndSongHeader {
- *   int id;
- *   {@literal @}ColumnInfo(name = "header")
- *   String header;
- * }
- * // DAO
- * {@literal @}Query("SELECT id, name || '-' || release_year AS header FROM user")
- * public IdAndSongHeader[] loadSongHeaders();
- * </pre>
- * If there is a mismatch between the query result and the POJO, Room will print a warning during
- * compilation.
- * <p>
- * Please see the documentation of individual classes for details.
- */
-package androidx.room;