Android 使用服务更新LiveData

我需要知道如何使用从主活动启动的服务更新LiveData对象的数据

我使用的是对象类、dao接口、存储库、房间数据库和视图模型

一切正常，在RoomDatabase中创建数据库时成功加载了数据，但是，我需要更新服务中生成的数据，问题是它需要下一行中的活动上下文：

LiveData wifiViewModel=ViewModelProviders.of（this.get）（wifiViewModel.class）

Dao接口：

@Dao
public interface WifiDao {

  @Insert(onConflict = OnConflictStrategy.IGNORE)
  void insert(WifiClass wifiObject);

  @Insert(onConflict = OnConflictStrategy.IGNORE)
  void insertAll(List<WifiClass> wifiList);

  @Query("DELETE FROM wifi_table")
  void deleteAll();

  @Query("SELECT * from wifi_table ORDER BY SSID ASC")
  LiveData<List<WifiClass>> getAllWifi();

  @Query("SELECT * from wifi_table LIMIT 1")
  WifiClass[] getAnyWifi();

}

@Dao
公共接口WifiDao{
@插入（onConflict=OnConflictStrategy.IGNORE）
空心插件（wifiglass wifiObject）；
@插入（onConflict=OnConflictStrategy.IGNORE）
void insertAll（列表wifiList）；
@查询（“从wifi_表中删除”）
void deleteAll（）；
@查询（“按SSID ASC从wifi_表顺序选择*）
LiveData getAllWifi（）；
@查询（“从wifi\u表限制1中选择*）
WifiClass[]getAnyWifi（）；
}

存储库：

public class WifiRepository {

  private WifiDao wifiDao;
  private LiveData<List<WifiClass>> allWifi;

  WifiRepository(Application application) {
    WifiRoomDatabase db = WifiRoomDatabase.getDatabase(application);
    wifiDao = db.wifiDao();
    allWifi = wifiDao.getAllWifi();
  }

  // Get all Wifi objects
  LiveData<List<WifiClass>> getAllWifi() {
    return allWifi;
  }

  //Insert one Wifi object
  public void insert (WifiClass wifiObject){
    new insertAsyncTask(wifiDao).execute(wifiObject);
  }

  private static class insertAsyncTask extends AsyncTask<WifiClass, Void, Void> {

    private WifiDao mAsyncTaskDao;

    insertAsyncTask(WifiDao wifiDao) {
      mAsyncTaskDao = wifiDao;
    }

    @Override
    protected Void doInBackground(final WifiClass... params) {
      mAsyncTaskDao.insert(params[0]);
      return null;
    }
  }
}

公共类WifiRepository{
私人维菲道维菲道；
私有LiveData-allWifi；
WifiRepository（应用程序）{
WifiRoomDatabase db=WifiRoomDatabase.getDatabase（应用程序）；
wifiDao=db.wifiDao（）；
allWifi=wifiDao.getAllWifi（）；
}
//获取所有Wifi对象
LiveData getAllWifi（）{
返回所有WiFi；
}
//插入一个Wifi对象
公共无效插入（WifiClass wifiObject）{
新建insertAsyncTask（wifiDao）.execute（wifiObject）；
}
私有静态类insertAsyncTask扩展了AsyncTask{
私人WifiDao mAsyncTaskDao；
insertAsyncTask（WifiDao WifiDao）{
mAsyncTaskDao=wifiDao；
}
@凌驾
受保护的空doInBackground（最终接线类…参数）{
mAsyncTaskDao.insert（参数[0]）；
返回null；
}
}
}

RoomDatabase:

@Database(entities = {WifiClass.class}, version = 1, exportSchema = false)
public abstract class WifiRoomDatabase extends RoomDatabase implements Serializable{

  public abstract WifiDao wifiDao();
  private static WifiRoomDatabase INSTANCE;
  public static Context context;

  static List<ScanResult> results;
  private static WifiManager wifiManager;

  public static WifiRoomDatabase getDatabase(final Context contextt) {
    context = contextt;
    if (INSTANCE == null) {
      synchronized (WifiRoomDatabase.class) {
        if (INSTANCE == null) {
          INSTANCE = Room.databaseBuilder(context.getApplicationContext(), WifiRoomDatabase.class, "wifi_database")
              .fallbackToDestructiveMigration() // Wipes and rebuilds
              .addCallback(sRoomDatabaseCallback) //
              .build();
        }
      }
    }
    return INSTANCE;
  }

  private static RoomDatabase.Callback sRoomDatabaseCallback = new RoomDatabase.Callback(){
    @Override
    public void onOpen (@NonNull SupportSQLiteDatabase db){
      super.onOpen(db);
      new PopulateDbAsync(INSTANCE).execute();

    }
  };


  //Populate the database in the background.
  private static class PopulateDbAsync extends AsyncTask<Void, Void, Void> {
    private final WifiDao mDao;

    PopulateDbAsync(WifiRoomDatabase db) {
      mDao = db.wifiDao();
    }

    @Override
    protected void onPreExecute() {
      super.onPreExecute();
      wifiManager = (WifiManager) context.getSystemService(WIFI_SERVICE);

      if (!wifiManager.isWifiEnabled()){
        //Toast.makeText(this, "Wifi disable... Activating...", Toast.LENGTH_SHORT).show();
        wifiManager.setWifiEnabled(true);
      }

        results = wifiManager.getScanResults();
        wifiManager.startScan();
        //Toast.makeText(this, "Scanning...", Toast.LENGTH_SHORT).show();
    }

    @Override
    protected Void doInBackground(Void... voids) {

      for (ScanResult scanResult : results) {
          String ssid = scanResult.SSID;
          if (ssid == null || ssid.isEmpty()){
            ssid = "Hide SSID";
          }
          String bssid = scanResult.BSSID;
          String capabilities = scanResult.capabilities;
          int level = scanResult.level;
          int frequency = scanResult.frequency;
          long timestamp = scanResult.timestamp;

        int passpoint; int channelWidth; int centerFreq0; int centerFreq1; int responder;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
          if (scanResult.isPasspointNetwork() == true) {
            passpoint = 1;
          }else{
            passpoint = 0;
          }
          channelWidth = scanResult.channelWidth;
          centerFreq0 = scanResult.centerFreq0;
          centerFreq1 = scanResult.centerFreq1;
          if (scanResult.is80211mcResponder() == true){
            responder = 1;
          }else{
            responder = 0;
          }
        }else{
          passpoint = 0;
          channelWidth = 0;
          centerFreq0 = 0;
          centerFreq1 = 0;
          responder = 0;

        }

          WifiClass wifiObject = new WifiClass(ssid, bssid, capabilities, level, frequency,
              timestamp, passpoint, channelWidth, centerFreq0, centerFreq1, responder);
          mDao.insert(wifiObject);
        }

      return null;
    }
  }

@Database（entities={WifiClass.class}，version=1，exportSchema=false）
公共抽象类WifiRoomDatabase扩展RoomDatabase实现可序列化{
公开摘要WifiDao WifiDao（）；
私有静态数据库实例；
公共静态语境；
静态列表结果；
私有静态WifiManager WifiManager；
公共静态WifiRoomDatabase getDatabase（最终上下文上下文）{
上下文=上下文；
if（实例==null）{
已同步（WifiRoomDatabase.class）{
if（实例==null）{
实例=Room.databaseBuilder（context.getApplicationContext（），WifiRoomDatabase.class，“wifi\u数据库”）
.fallbackToDestructiveMigration（）//擦除和重建
.addCallback（sRoomDatabaseCallback）//
.build（）；
}
}
}
返回实例；
}
私有静态RoomDatabase.Callback sRoomDatabaseCallback=新建RoomDatabase.Callback（）{
@凌驾
public void onOpen（@NonNull SupportSQLiteDatabase db）{
super.onOpen（db）；
新填充的Basync（实例）.execute（）；
}
};
//在后台填充数据库。
私有静态类填充Basync扩展异步任务{
私人最终维菲多-马道；
PopulateDbAsync（WifiRoomDatabase db）{
mDao=db.wifiDao（）；
}
@凌驾
受保护的void onPreExecute（）{
super.onPreExecute（）；
wifiManager=（wifiManager）context.getSystemService（WIFI_服务）；
如果（！wifiManager.isWifiEnabled（））{
//Toast.makeText（这是“Wifi禁用…激活…”），Toast.LENGTH_SHORT.show（）；
wifiManager.setWifiEnabled（true）；
}
results=wifiManager.getScanResults（）；
wifiManager.startScan（）；
//Toast.makeText（这是“扫描…”，Toast.LENGTH_SHORT.show（）；
}
@凌驾
受保护的空位背景（空位…空位）{
用于（扫描结果扫描结果：结果）{
字符串ssid=scanResult.ssid；
if（ssid==null | | ssid.isEmpty（））{
ssid=“隐藏ssid”；
}
字符串bssid=scanResult.bssid；
字符串能力=scanResult.capabilities；
int-level=scanResult.level；
int frequency=scanResult.frequency；
长时间戳=scanResult.timestamp；
int-passpoint；int-channelWidth；int-centerFreq0；int-centerFreq1；int-responder；
if（android.os.Build.VERSION.SDK\u INT>=android.os.Build.VERSION\u code.M）{
if（scanResult.isPasspointNetwork（）==true）{
passpoint=1；
}否则{
passpoint=0；
}
channelWidth=scanResult.channelWidth；
centerFreq0=scanResult.centerFreq0；
centerFreq1=scanResult.centerFreq1；
if（scanResult.is80211mCrespound（）==true）{
应答者=1；
}否则{
应答器=0；
}
}否则{
passpoint=0；
通道宽度=0；
中心频率0=0；
中心频率1=0；
应答器=0；
}
WifiClass wifiObject=新的WifiClass（ssid、bssid、能力、级别、频率、，
时间戳、密码点、通道宽度、centerFreq0、centerFreq1、响应器）；
mDao.insert（wifiObject）；
}
返回null；
}
}

视图模型：

public class WifiViewModel extends AndroidViewModel {

  private WifiRepository wifiRepository;
  private LiveData<List<WifiClass>> allWifi;

  public WifiViewModel(@NonNull Application application) {
    super(application);
    wifiRepository = new WifiRepository(application);
    allWifi = wifiRepository.getAllWifi();
  }

  LiveData<List<WifiClass>> getAllWifi() {
    return allWifi;
  }

  public void insert(WifiClass wifiObject) {
    wifiRepository.insert(wifiObject);
  }

}

公共类WifiViewModel扩展了AndroidViewModel{
私家侦探；
私有LiveData-allWifi；
公共WifiViewModel（@NonNull应用程序）{
超级（应用）；
wifiRepository=新wifiRepository（应用程序）；
allWifi=wifiRepository.getAllWifi（）；
}
LiveData getAllWifi（）{
返回所有WiFi；
}
公共无效插入（WifiClass wifiObject）{
wifiRepository.insert（wifiObject）；
}
}

服务：

public class Wifi_Service extends IntentService {

  private Handler handler;
  private Runnable runnable;
  private static Context classContext;

  //private static WifiViewModel wifiViewModel;
  static List<ScanResult> results;
  private static WifiManager wifiManager;
  private LiveData<List<WifiClass>> mAllWifi;


  public Wifi_Service(/*WifiRoomDatabase db*/) {
    super("wifi_service");
  }

  @Override
  protected void onHandleIntent(Intent intent) {

  }

  //Populate the database in the background.
  private static class PopulateDbAsync extends AsyncTask<Void, Void, Void> {
    private final WifiDao mDao;

    PopulateDbAsync(WifiRoomDatabase db) {
      mDao = db.wifiDao();
    }

    @Override
    protected void onPreExecute() {
      super.onPreExecute();
      wifiManager = (WifiManager) classContext.getApplicationContext().getSystemService(WIFI_SERVICE);

      if (!wifiManager.isWifiEnabled()){
        Toast.makeText(classContext, "Wifi disable... Activating...", Toast.LENGTH_SHORT).show();
        wifiManager.setWifiEnabled(true);
      }

      results = wifiManager.getScanResults();
      wifiManager.startScan();
      Toast.makeText(classContext, "Scanning...", Toast.LENGTH_SHORT).show();
    }

    @Override
    protected Void doInBackground(Void... voids) {

      for (ScanResult scanResult : results) {
        String ssid = scanResult.SSID;
        if (ssid == null || ssid.isEmpty()){
          ssid = "Hide SSID";
        }
        String bssid = scanResult.BSSID;
        String capabilities = scanResult.capabilities;
        int level = scanResult.level;
        int frequency = scanResult.frequency;
        long timestamp = scanResult.timestamp;

        int passpoint; int channelWidth; int centerFreq0; int centerFreq1; int responder;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
          if (scanResult.isPasspointNetwork() == true) {
            passpoint = 1;
          }else{
            passpoint = 0;
          }
          channelWidth = scanResult.channelWidth;
          centerFreq0 = scanResult.centerFreq0;
          centerFreq1 = scanResult.centerFreq1;
          if (scanResult.is80211mcResponder() == true){
            responder = 1;
          }else{
            responder = 0;
          }
        }else{
          passpoint = 0;
          channelWidth = 0;
          centerFreq0 = 0;
          centerFreq1 = 0;
          responder = 0;

        }

        WifiClass wifiObject = new WifiClass(ssid, bssid, capabilities, level, frequency,
            timestamp, passpoint, channelWidth, centerFreq0, centerFreq1, responder);

      //The problem
        wifiViewModel.insert(wifiObject);
      }

      return null;
    }

    @Override
    protected void onPostExecute(Void aVoid) {
      super.onPostExecute(aVoid);
      Toast.makeText(classContext, "Scanning finished", Toast.LENGTH_SHORT).show();

    }
  }

  @Override
  public void onStart(Intent intent, int startId) {
    super.onStart(intent, startId);
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
    Toast.makeText(this, "Scanning...", Toast.LENGTH_SHORT).show();

    Bundle extras = intent.getExtras();
    if(extras == null) {
      Log.d("Service", "null");
    }else {
      Log.d("Service","not null");
      classContext = getApplicationContext();
    }

//The problem
//   wifiViewModel = ViewModelProviders.of(this).get(WifiViewModel.class);
//    mWifiViewModel.getAllWifi().observe(this, new Observer<List<WifiClass>>() {
//      @Override
//      public void onChanged(@Nullable List<WifiClass> wifiClasses) {
//
//      }
//    });


    return super.onStartCommand(intent, flags, startId);
  }

  @Override
  public void onDestroy() {
    Toast.makeText(this, "Destroy scanning service", Toast.LENGTH_SHORT).show();

    super.onDestroy();
  }
}

公共级Wifi\u服务扩展了IntentService{
私人经办人；
私人可运行；
私有静态上下文类上下文；
//私有静态WifiViewModel WifiViewModel；
静态列表结果；
私有静态WifiManager WifiManager；
私有LiveData mAllWi
WifiRoomDatabase db = WifiRoomDatabase.getDatabase(getApplicationContext());
db.wifiDao().insert(wifiObject);