Android Activity自定义类委托实践

1. 理解Java的单继承限制与Android Activity的特殊性

在Java编程语言中，类只允许单继承，即一个类只能直接继承自一个父类。这意味着，如果一个类A已经继承了类B，它就不能再同时继承类C。

对于Android开发而言，所有用于显示用户界面的Activity都必须直接或间接继承自android.app.Activity。为了兼容旧版本Android系统并利用Material Design等特性，我们通常会继承androidx.appcompat.app.AppCompatActivity。例如，在问题描述中，HereMap类已经声明为：

public class HereMap extends AppCompatActivity {
    // ...
}

这表示HereMap已经占据了其唯一的继承槽。因此，试图让HereMap同时继承另一个自定义类HereMapClass（例如public class HereMap extends AppCompatActivity, HereMapClass）在Java中是语法错误的，因为Java不支持多重继承。

2. 解决方案：委托模式 (Delegation Pattern)

当一个类需要另一个类的功能，但又不能通过继承来实现时，委托模式提供了一个优雅的解决方案。委托模式的核心思想是：一个对象（委托者，Delegator）不直接执行某个任务，而是将该任务的执行“委托”给另一个对象（被委托者，Delegatee）。委托者持有被委托者的引用，并在需要时调用被委托者的方法。

委托模式的优势：

• 规避单继承限制： 允许一个类在不继承另一个类的情况下复用其功能。
• 职责分离： 清晰地划分了不同对象的职责。Activity专注于UI和生命周期管理，而自定义类专注于其特定的业务逻辑（如地图数据下载、POI管理等）。
• 提高灵活性和可维护性： 委托者与被委托者之间的耦合度较低，更容易修改和替换。
• 代码复用： HereMapClass可以在多个Activity或非UI组件中被复用，而无需复制其核心逻辑。

3. 实现委托模式的步骤与示例

根据问题描述，HereMapClass旨在管理地图下载等非视觉操作，而HereMap Activity则负责在UI上显示地图。这正是委托模式的理想应用场景。

3.1 明确HereMapClass的职责

首先，我们需要确保HereMapClass只包含与地图逻辑、数据管理相关的功能，而不直接包含UI组件（如MapView或AndroidXMapFragment），因为这些通常由Activity管理。如果HereMapClass需要与地图视图交互，它可以通过方法参数接收Map对象或回调接口。

根据提供的代码，HereMapClass中包含了一些UI相关的成员变量（如MapView view，ProgressBar downloadProgressBar），这些应该从HereMapClass中移除，并由HereMap Activity来管理。HereMapClass应专注于地图引擎、加载、定位等逻辑。

优化后的HereMapClass示例：

import android.content.Context;
import android.util.Log;
import android.widget.ProgressBar; // 注意：ProgressBar的更新可能需要UI线程，后续处理
import android.widget.Toast;

import com.here.sdk.mapview.MapEngine; // 假设SDK的导入
import com.here.sdk.mapview.MapLoader;
import com.here.sdk.mapview.MapPackage;
import com.here.sdk.mapview.PositioningManager;
import com.here.sdk.core.GeoCoordinate;

import org.json.JSONArray;
import java.util.ArrayList;

public class HereMapClass {

    private final static String TAG = HereMapClass.class.getSimpleName();
    private Context context; // 用于Toast等需要Context的操作

    // 地图核心逻辑相关的成员变量
    private MapEngine mapEngine;
    private MapLoader mapLoader;
    private PositioningManager positioningManager = null;
    private PositioningManager.OnPositionChangedListener positionListener;
    private GeoCoordinate currentPosition;

    private ArrayList currentInstalledMaps;
    private String currentInstalledMapsString;

    // 业务数据
    JSONArray jsonPoints;
    JSONArray jsArray;
    ArrayList poiArr;
    String gpsFolder;
    String poiFolder;
    String loopName = "";
    String loopLang = "";
    String loopEvent = "";

    // 注意：ProgressBar不再是HereMapClass的成员，需要通过接口或参数传递更新
    private ProgressBar externalProgressBar; // 委托者传递进来的ProgressBar引用

    // 构造函数，接收Context
    public HereMapClass(Context context) {
        this.context = context;
        // 在这里初始化MapEngine等非UI组件
        MapEngine.getInstance().init(() -> {
            Log.d(TAG, "MapEngine initialized.");
            mapEngine = MapEngine.getInstance();
            mapLoader = mapEngine.getMapLoader();
            // 可以立即请求地图包列表
            requestMapPackages();
        });
        currentInstalledMaps = new ArrayList<>();
    }

    // 设置外部进度条，用于更新UI
    public void setDownloadProgressBar(ProgressBar progressBar) {
        this.externalProgressBar = progressBar;
    }

    // 地图加载器监听器，用于处理地图包下载进度和结果
    private MapLoader.Listener mapLoaderHandler = new MapLoader.Listener() {
        @Override
        public void onProgress(int progress) {
            Log.i(TAG, "Progress " + progress + "%");
            if (externalProgressBar != null) {
                // 注意：UI更新必须在主线程，这里只是示例，实际需要Handler或runOnUiThread
                externalProgressBar.setProgress(progress);
            }
        }

        @Override
        public void onInstallationSize(long diskSize, long networkSize) {
            Log.i(TAG, "Map data require " + diskSize + " bytes on disk, " + networkSize + " bytes for download.");
        }

        @Override
        public void onGetMapPackagesComplete(MapPackage rootMapPackage, MapLoader.ResultCode resultCode) {
            if (resultCode == MapLoader.ResultCode.OPERATION_SUCCESSFUL) {
                Log.i(TAG, "Map packages received successful: " + rootMapPackage.getTitle());
                currentInstalledMaps.clear();
                populateInstalledMaps(rootMapPackage);
                updateInstalledMapsString();
            } else {
                Log.e(TAG, "Can't retrieve map packages: " + resultCode.name());
                Toast.makeText(context, "Error: " + resultCode.name(), Toast.LENGTH_SHORT).show();
            }
        }

        private void populateInstalledMaps(MapPackage pac) {
            if (pac.getInstallationState() == MapPackage.InstallationState.INSTALLED) {
                Log.i(TAG, "Installed package found: " + pac.getTitle() + " id " + pac.getId());
                currentInstalledMaps.add(pac);
            } else if (pac.getChildren() != null && pac.getChildren().size() > 0) {
                for (MapPackage p : pac.getChildren()) {
                    populateInstalledMaps(p);
                }
            }
        }

        private void updateInstalledMapsString() {
            StringBuilder sb = new StringBuilder();
            for (MapPackage pac : currentInstalledMaps) {
                sb.append(pac.getTitle());
                sb.append("\n");
            }
            currentInstalledMapsString = sb.toString();
            Log.d(TAG, "Installed Maps:\n" + currentInstalledMapsString);
        }
    };

    // 公共方法：请求地图包列表
    public void requestMapPackages() {
        if (mapLoader != null) {
            mapLoader.getMapPackages(mapLoaderHandler);
        } else {
            Log.e(TAG, "MapLoader is not initialized.");
        }
    }

    // 公共方法：开始下载地图包（示例）
    public void startMapDownload(MapPackage mapPackage) {
        if (mapLoader != null) {
            mapLoader.installMapPackages(java.util.Collections.singletonList(mapPackage), mapLoaderHandler);
        }
    }

    // 获取已安装地图列表的字符串表示
    public String getInstalledMapsInfo() {
        return currentInstalledMapsString;
    }

    // 其他地图逻辑方法...
    // 例如：初始化定位管理器
    public void initializePositioningManager() {
        if (positioningManager == null) {
            positioningManager = PositioningManager.getInstance();
            // ... 配置positionListener ...
            positioningManager.start(PositioningManager.LocationMethod.GPS_NETWORK);
        }
    }

    // 生命周期管理方法（供Activity调用）
    public void onResume() {
        if (positioningManager != null) {
            positioningManager.start(PositioningManager.LocationMethod.GPS_NETWORK);
        }
    }

    public void onPause() {
        if (positioningManager != null) {
            positioningManager.stop();
        }
    }

    public void onDestroy() {
        // 释放资源
        if (positioningManager != null) {
            positioningManager.stop();
            positioningManager = null;
        }
        if (mapEngine != null) {
            mapEngine.dispose(); // 假设有dispose方法
            mapEngine = null;
        }
        Log.d(TAG, "HereMapClass resources disposed.");
    }
}

3.2 HereMap Activity实现委托

HereMap Activity将持有HereMapClass的一个实例，并在其生命周期方法中调用HereMapClass相应的方法。

HereMap Activity示例：

import android.os.Bundle;
import android.util.Log;
import android.widget.ProgressBar;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;

import com.here.sdk.mapview.MapError;
import com.here.sdk.mapview.MapScene;
import com.here.sdk.mapview.MapView;
import com.here.sdk.core.GeoCoordinates;

public class HereMap extends AppCompatActivity {

    private final static String TAG = HereMap.class.getSimpleName();

    // UI 组件，由Activity直接管理
    private MapView mapView;
    private ProgressBar downloadProgressBar;
    private TextView installedMapsTextView;

    // 委托对象
    private HereMapClass hereMapDelegate;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_here_map); // 假设有一个包含MapView和ProgressBar的布局

        // 初始化UI组件
        mapView = findViewById(R.id.map_view); // 假设布局中MapView的id为map_view
        mapView.onCreate(savedInstanceState); // 调用MapView的生命周期方法

        downloadProgressBar = findViewById(R.id.download_progress_bar); // 假设布局中ProgressBar的id
        installedMapsTextView = findViewById(R.id.installed_maps_text_view); // 假设布局中TextView的id

        // 初始化委托对象
        hereMapDelegate = new HereMapClass(this);
        hereMapDelegate.setDownloadProgressBar(downloadProgressBar); // 将Activity的ProgressBar传递给委托对象

        // 配置地图视图
        mapView.get
        mapView.get /// 假设这里是获取Map对象
        mapView.get  // 假设这里是加载地图场景
        mapView.getMapScene().loadScene(MapScene.BuiltInSchemes.NORMAL_DAY, new MapScene.LoadSceneCallback() {
            @Override
            public void onLoadScene(MapError mapError) {
                if (mapError == null) {
                    Log.d(TAG, "Map scene loaded successfully.");
                    // 地图加载成功后，可以调用委托对象的方法进行地图逻辑操作
                    hereMapDelegate.requestMapPackages(); // 请求地图包列表
                    hereMapDelegate.initializePositioningManager(); // 初始化定位
                } else {
                    Log.e(TAG, "Map scene loading failed: " + mapError.name());
                }
            }
        });

        // 示例：获取并显示已安装地图信息
        // 实际中可能需要一个回调机制，当hereMapDelegate完成操作后通知Activity更新UI
        // 这里简化为直接调用
        updateInstalledMapsInfo();
    }

    private void updateInstalledMapsInfo() {
        // 由于mapLoaderHandler是异步的，这里可能不会立即获取到最新数据
        // 更好的做法是HereMapClass通过接口回调通知Activity更新UI
        String info = hereMapDelegate.getInstalledMapsInfo();
        if (info != null && !info.isEmpty()) {
            installedMapsTextView.setText("Installed Maps:\n" + info);
        } else {
            installedMapsTextView.setText("No map packages installed or info not available yet.");
        }
    }


    @Override
    protected void onResume() {
        super.onResume();
        mapView.onResume(); // 调用MapView的生命周期方法
        hereMapDelegate.onResume(); // 调用委托对象的生命周期方法
    }

    @Override
    protected void onPause() {
        super.onPause();
        mapView.onPause(); // 调用MapView的生命周期方法
        hereMapDelegate.onPause(); // 调用委托对象的生命周期方法
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mapView.onDestroy(); // 调用MapView的生命周期方法
        hereMapDelegate.onDestroy(); // 调用委托对象的生命周期方法
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        mapView.onSaveInstanceState(outState); // 调用MapView的生命周期方法
    }
}

布局文件 activity_here_map.xml 示例：

4. 注意事项与最佳实践

1. UI更新： HereMapClass中的mapLoaderHandler在更新ProgressBar时，需要确保是在UI线程中进行。可以通过Activity.runOnUiThread()方法或者使用Handler来处理。

   // 在HereMapClass的onProgress方法中
   if (externalProgressBar != null && context instanceof Activity) {
       ((Activity) context).runOnUiThread(() -> externalProgressBar.setProgress(progress));
   }

2. 生命周期管理： 委托对象HereMapClass的初始化和资源释放应与HereMap Activity的生命周期同步。在onCreate中初始化，在onResume和onPause中管理定位等动态资源，在onDestroy中释放所有资源。

3. 通信机制： 如果HereMapClass需要将事件或数据反馈给HereMap Activity（例如，地图下载完成、定位更新），可以定义一个接口（Callback Interface）。HereMap Activity实现该接口，并将自身作为监听器传递给HereMapClass。

   // 定义接口
   public interface MapOperationListener {
       void onMapPackagesDownloaded(String info);
       void onPositionUpdated(GeoCoordinate position);
       // ... 其他回调
   }
   
   // HereMapClass中
   private MapOperationListener listener;
   public void setMapOperationListener(MapOperationListener listener) {
       this.listener = listener;
   }
   // 当事件发生时：
   if (listener != null) {
       listener.onMapPackagesDownloaded(currentInstalledMapsString);
   }
   
   // HereMap Activity中
   public class HereMap extends AppCompatActivity implements MapOperationListener {
       // ...
       @Override
       protected void onCreate(...) {
           // ...
           hereMapDelegate.setMapOperationListener(this);
           // ...
       }
   
       @Override
       public void onMapPackagesDownloaded(String info) {
           runOnUiThread(() -> installedMapsTextView.setText("Installed Maps:\n" + info));
       }
       // ...
   }

4. Context的正确使用： HereMapClass接收Context是正确的，但应注意避免持有Activity的强引用导致内存泄漏。如果HereMapClass的生命周期可能超出Activity，应考虑使用ApplicationContext，或者在onDestroy中将Context引用置空。在上述示例中，由于HereMapClass的生命周期与Activity绑定，且在onDestroy中进行了清理，因此问题不大。

5. 职责边界： 始终保持Activity专注于UI和用户交互，将复杂的业务逻辑和数据处理委托给其他纯Java类。这有助于构建更健壮、可测试和可维护的应用程序。

总结

通过采用委托模式，我们成功地解决了Android开发中Activity“多重继承”的难题。HereMap Activity专注于其UI展示和Android生命周期管理，而HereMapClass则封装了地图相关的核心业务