现在代码是这样的 Pigeon flyPigeon = Pigeon.newBuilder(MyTestActivity.this).setAuthority(“com.hztc.iflashs

现在代码是这样的 

 Pigeon flyPigeon = Pigeon.newBuilder(MyTestActivity.this).setAuthority("com.hztc.iflashsee").build();
                    Bundle bundleSend = new Bundle();
                    bundleSend.putInt("msgType", 2);
                    bundleSend.putBoolean("JobRunning", isCurrentJobRunning);
                    Bundle bundle = flyPigeon.route("/send/command").withBundle("EyeAlignment", bundleSend).fly();
改成这样的写法  封装成以下
   public String sendThreeCommand(String axle, int plus, int steps) {
        HashMap<String, Object> params = new HashMap<>();
        params.put(CommandSender.MoveSteps, axle);
        params.put(CommandSender.Direction, plus);
        params.put(CommandSender.steps, steps);
        String result = CommandSender.getInstance(MyTestActivity.this).sendCommand(CommandSender.ThreeDMoto_Command, params);
        return result;
    }

要将现有的代码重构并封装成指定的方法，我们需要创建一个工具类 `CommandSender`，它将负责发送命令。以下是如何实现的示例：

### 1. 创建工具类 `CommandSender`

```java
import android.content.Context;
import com.github.pwittchen.pigeon.Pigeon;
import com.github.pwittchen.pigeon.library.PigeonBuilder;
import com.google.gson.Gson;

import java.util.HashMap;
import java.util.Map;

public class CommandSender {
    private static CommandSender instance;
    private static final String TAG = "CommandSender";
    private static final String AUTHORITY = "com.hztc.iflashsee";
    private static final String ROUTE_SEND_COMMAND = "/send/command";
    private static final String ROUTE_THREE_DMOTO_COMMAND = "ThreeDMoto_Command";
    private final Pigeon flyPigeon;
    private final Gson gson = new Gson();

    private CommandSender(Context context) {
        flyPigeon = Pigeon.newBuilder(context).setAuthority(AUTHORITY).build();
    }

    public static synchronized CommandSender getInstance(Context context) {
        if (instance == null) {
            instance = new CommandSender(context);
        }
        return instance;
    }

    public String sendCommand(String command, Map<String, Object> params) {
        HashMap<String, Object> paramsMap = new HashMap<>(params);
        String json = gson.toJson(paramsMap);
        Log.e(TAG, "sendCommand: " + command + " with params: " + json);

        Bundle bundleSend = new Bundle();
        for (Map.Entry<String, Object> entry : paramsMap.entrySet()) {
            bundleSend.putString(entry.getKey(), String.valueOf(entry.getValue()));
        }

        Bundle bundle = flyPigeon.route(ROUTE_SEND_COMMAND).withBundle("EyeAlignment", bundleSend).fly();
        String result = bundle.getString("responseResult");
        return result != null ? result : "No response";
    }
}
```

### 2. 在你的 `Activity` 中使用 `CommandSender`

```java
public class MyTestActivity extends AppCompatActivity {
    private static final String TAG = "MyTestActivity";
    private boolean isCurrentJobRunning;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my_test);

        // 示例：发送命令
        String result = sendThreeCommand("MoveSteps", 1, 10);
        Log.e(TAG, "Command result: " + result);
    }

    public String sendThreeCommand(String axle, int plus, int steps) {
        HashMap<String, Object> params = new HashMap<>();
        params.put(axle, steps); // 假设axle是CommandSender.MoveSteps
        params.put("Direction", plus); // 假设plus是CommandSender.Direction
        params.put("steps", steps);
        String result = CommandSender.getInstance(this).sendCommand(CommandSender.ROUTE_THREE_DMOTO_COMMAND, params);
        return result;
    }
}
```

### 说明：

1. **CommandSender 类**：这个类是一个单例，负责发送命令。它使用 Gson 库将参数转换为 JSON 字符串，并发送命令。
2. **sendCommand 方法**：这个方法接受一个命令名称和一个参数映射，将参数转换为 JSON 字符串，然后发送命令并返回结果。
3. **getInstance 方法**：这是一个静态工厂方法，用于获取 `CommandSender` 的单例实例。它确保在应用程序中只有一个 `CommandSender` 实例。
4. **在 Activity 中使用**：在你的 `Activity` 中，调用 `sendThreeCommand` 方法来发送命令。

### 注意：

- 确保你已经添加了 Pigeon 库和 Gson 库的依赖项到你的 `build.gradle` 文件中。
- 这个示例中的 `sendCommand` 方法只是模拟发送命令的过程，实际中你可能需要通过网络发送命令，例如使用 Retrofit、OkHttp 或其他网络库发送 HTTP 请求。
- 确保 `CommandSender` 类中的 `AUTHORITY`、`ROUTE_SEND_COMMAND` 和 `ROUTE_THREE_DMOTO_COMMAND` 常量与你的实际需求匹配。

**Pigeon 库依赖**（如果使用 Gradle）：

```gradle
dependencies {
    implementation 'com.github.pwittchen:pigeon:1.0.0'
}
```

**Gson 库依赖**（如果使用 Gradle）：

```gradle
dependencies {
    implementation 'com.google.code.gson:gson:2.8.6'
}
```

通过这种方式，你可以将发送命令的逻辑封装在一个单独的工具类中，使代码更加模块化和可重用。