Java 无法解析方法'；激活蚀刻'；在'；FirebaseRemoteConfig'；

我如何解决这个问题？我正在为Firebase自动更新设置我的应用程序，我得到了一个已经构建的Android studio项目，该项目包含我复制到应用程序中的完整代码

已经构建的项目Firebase更新（远程配置）非常好，我能够构建apk而没有问题

但是，当我将代码和依赖项复制到我的应用程序时，我在构建应用程序时出错，

ForeceUpgradeManger.java

显示两行错误

无法解析“FirebaseRemoteConfig”中的方法“setDefaults”

无法解析“FirebaseRemoteConfig”中的方法“activateFetched”

下面是完整的代码

import android.app.Activity;
import android.app.Application;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AlertDialog;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;
import androidx.lifecycle.ProcessLifecycleOwner;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.remoteconfig.FirebaseRemoteConfig;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.Map;

public class ForceUpgradeManager implements LifecycleObserver {

  private static final String KEY_UPDATE_REQUIRED = "force_update_required";
  private static final String KEY_CURRENT_VERSION = "force_update_current_version";

  private static final String TAG = "ForceUpgradeManager";

  private final Context context;

  @Nullable
  private WeakReference<Activity> activityWeakReference;

  public ForceUpgradeManager(ForceUpdateApp application) {
    this.context = application.getApplicationContext();
    application.registerActivityLifecycleCallbacks(callbacks);
    ProcessLifecycleOwner.get().getLifecycle().addObserver(this);
  }

  @OnLifecycleEvent(Lifecycle.Event.ON_START)
  public void appStarted() {
    checkForceUpdateNeeded();
  }

  @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
  public void appStopped() {
    if (activityWeakReference != null) {
      activityWeakReference.clear();
    }
  }

  @Nullable
  private Activity getCurrentActivity() {
    return activityWeakReference != null && activityWeakReference.get() != null
        ? activityWeakReference.get() : null;
  }

  private final Application.ActivityLifecycleCallbacks callbacks =
      new Application.ActivityLifecycleCallbacks() {

        @Override
        public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle bundle) {
        }

        @Override
        public void onActivityStarted(@NonNull Activity activity) {
          ForceUpgradeManager.this.activityWeakReference = new WeakReference<>(activity);
        }

        @Override
        public void onActivityResumed(@NonNull Activity activity) {

        }

        @Override
        public void onActivityPaused(@NonNull Activity activity) {

        }

        @Override
        public void onActivityStopped(@NonNull Activity activity) {

        }

        @Override
        public void onActivitySaveInstanceState(@NonNull Activity activity,
            @NonNull Bundle bundle) {

        }

        @Override
        public void onActivityDestroyed(@NonNull Activity activity) {

        }
      };

  /**
   * Gets update alert.
   */
  private void onUpdateNeeded() {
    Activity temp = getCurrentActivity();
    if (temp != null) {
      AlertDialog dialog = new AlertDialog.Builder(temp)
          .setTitle("New version available")
          .setMessage("Please update app for seamless experience.")
          .setPositiveButton("Continue",
              new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                  redirectStore();
                }
              }).create();
      dialog.show();
    }
  }

  /**
   * Redirect to play store
   */
  private void redirectStore() {
    Uri updateUrl = Uri.parse("market://details?id=" + context.getPackageName());
    final Intent intent = new Intent(Intent.ACTION_VIEW, updateUrl);
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    context.startActivity(intent);
  }

  private void checkForceUpdateNeeded() {
    final FirebaseRemoteConfig remoteConfig = FirebaseRemoteConfig.getInstance();
    // long cacheExpiration = 12 * 60 * 60; // fetch every 12 hours
    // set in-app defaults
    Map<String, Object> remoteConfigDefaults = new HashMap();
    remoteConfigDefaults.put(KEY_UPDATE_REQUIRED, false);
    remoteConfigDefaults.put(KEY_CURRENT_VERSION, "1.0.0");

    remoteConfig.setDefaults(remoteConfigDefaults);
    remoteConfig.fetch(0)
        .addOnCompleteListener(new OnCompleteListener<Void>() {
          @Override
          public void onComplete(@NonNull Task<Void> task) {
            if (task.isSuccessful()) {
              Log.d(TAG, "remote config is fetched.");
              remoteConfig.activateFetched();
            }
            if (remoteConfig.getBoolean(KEY_UPDATE_REQUIRED)) {
              String currentVersion = remoteConfig.getString(KEY_CURRENT_VERSION);
              String appVersion = getAppVersion(context);
              if (!TextUtils.equals(currentVersion, appVersion)) {
                onUpdateNeeded();
              }
            }
          }
        });
  }

  private String getAppVersion(Context context) {
    String result = "";
    try {
      result = context.getPackageManager()
          .getPackageInfo(context.getPackageName(), 0)
          .versionName;
      result = result.replaceAll("[a-zA-Z]|-", "");
    } catch (PackageManager.NameNotFoundException e) {
      Log.e(TAG, e.getMessage());
    }

    return result;
  }
}

导入android.app.Activity；
导入android.app.Application；
导入android.content.Context；
导入android.content.DialogInterface；
导入android.content.Intent；
导入android.content.pm.PackageManager；
导入android.net.Uri；
导入android.os.Bundle；
导入android.text.TextUtils；
导入android.util.Log；
导入androidx.annotation.NonNull；
导入androidx.annotation.Nullable；
导入androidx.appcompat.app.AlertDialog；
导入androidx.lifecycle.lifecycle；
导入androidx.lifecycle.LifecycleObserver；
导入androidx.lifecycle.onLifecycle事件；
导入androidx.lifecycle.ProcessLifecycleOwner；
导入com.google.android.gms.tasks.OnCompleteListener；
导入com.google.android.gms.tasks.Task；
导入com.google.firebase.remoteconfig.firebasemoteconfig；
导入java.lang.ref.WeakReference；
导入java.util.HashMap；
导入java.util.Map；
公共类ForceUpgradeManager实现LifecycleObserver{
私有静态最终字符串密钥\u UPDATE\u REQUIRED=“force\u UPDATE\u REQUIRED”；
私有静态最终字符串密钥\u当前\u版本=“强制更新\u当前\u版本”；
私有静态最终字符串标记=“ForceUpgradeManager”；
私人最终语境；
@可空
私人WeakReference活动WeakReference；
公共ForceUpgradeManager（ForceUpdateApp应用程序）{
this.context=application.getApplicationContext（）；
application.registerActivityLifecycleCallbacks（回调）；
ProcessLifecycleOwner.get（）.getLifecycle（）.addObserver（此）；
}
@onLiFeCycleeEvent（Lifecycle.Event.ON_START）
public void appStarted（）{
CheckForceUpdateNeed（）；
}
@onLiFeCycleeEvent（Lifecycle.Event.ON_STOP）
公共无效appStopped（）{
if（activityWeakReference！=null）{
activityWeakReference.clear（）；
}
}
@可空
私有活动getCurrentActivity（）{
返回activityWeakReference！=null&&activityWeakReference.get（）！=null
？activityWeakReference.get（）：null；
}
private final Application.ActivityLifecycleCallbacks回调=
新应用程序。ActivityLifecycleCallbacks（）{
@凌驾
已创建ActivityCreated（@NonNull Activity，@Nullable Bundle）上的公共无效{
}
@凌驾
ActivityStarted上的公共无效（@NonNull Activity）{
ForceUpgradeManager.this.activityWeakReference=新的WeakReference（活动）；
}
@凌驾
在ActivityResumed上的公共无效（@NonNull Activity）{
}
@凌驾
活动引发的公共无效（@NonNull活动）{
}
@凌驾
ActivityStopped上的公共无效（@NonNull Activity）{
}
@凌驾
ActivitySaveInstanceState上的公共无效（@NonNull Activity-Activity，
@非空绑定（绑定）{
}
@凌驾
在ActivityDestroyed上的公共无效（@NonNull Activity-Activity）{
}
};
/**
*获取更新警报。
*/
私有void onUpdateRequired（）{
活动温度=getCurrentActivity（）；
如果（温度！=null）{
AlertDialog=新建AlertDialog.Builder（临时）
.setTitle（“新版本可用”）
.setMessage（“请更新应用程序以获得无缝体验。”）
.setPositiveButton（“继续”，
新建DialogInterface.OnClickListener（）{
@凌驾
public void onClick（DialogInterface dialog，int which）{
重定向存储（）；
}
}).create（）；
dialog.show（）；
}
}
/**
*重定向到play store
*/
私有无效重定向存储（）{
Uri updateUrl=Uri.parse（“market://details?id=“+context.getPackageName（））；
最终意图=新意图（Intent.ACTION\u视图，updateUrl）；
intent.addFlags（intent.FLAG\u活动\u新任务）；
背景。开始触觉（意图）；
}
私有void checkForceUpdateNeeded（）{
最终的FirebaseRemoteConfig remoteConfig=FirebaseRemoteConfig.getInstance（）；
//long cacheExpiration=12*60*60；//每12小时获取一次
//设置应用内默认值
Map remoteConfigDefaults=newhashmap（）；
remoteConfigDefaults.put（需要密钥更新，false）；
remoteConfigDefaults.put（键为当前版本，“1.0.0”）；
remoteConfig.setDefaults（remoteConfigDefaults）；
remoteConfig.fetch（0）
.addOnCompleteListener（新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
d（标记“远程配置已获取”）；
remoteConfig.activateFetched（）；
}
if（remoteConfig.getBoolean（需要更新键））{
String currentVersion=remoteConfig.getString（KEY\u CURRENT\u VERSION）；
字符串appVersion=getAppVersion（上下文）；
如果（！TextUtils.equals（currentVersion，appVersion））{
onUpdateRequired（）；
}
}
}
});
}
私有字符串getAppVersion（上下文）{
字符串结果=”；
试一试{
结果=context.getPackageManager（）
.getPackageInfo（context.getPackageName（），0）
.versionName；
结果=结果.replaceAll（“[a-zA-Z]|-”，”）；
}捕获（PackageManager.NameNotFounde异常）
remoteConfig.activate();