GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/vscode-react-native

Public

mirrored fromhttps://github.com/microsoft/vscode-react-nativeAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
0.5.1

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

vscode-react-native/src/extension/android

src/extension/android/androidPlatform.ts

234lines · modecode

RawDownload
Latest commit unavailable.
1// Copyright (c) Microsoft Corporation. All rights reserved.
2// Licensed under the MIT license. See LICENSE file in the project root for details.
3
4import * as Q from "q";
5import * as semver from "semver";
6
7import {GeneralMobilePlatform, MobilePlatformDeps } from "../generalMobilePlatform";
8import {IAndroidRunOptions} from "../launchArgs";
9import {AdbHelper, AndroidAPILevel, IDevice} from "./adb";
10import {Package} from "../../common/node/package";
11import {PromiseUtil} from "../../common/node/promise";
12import {PackageNameResolver} from "./packageNameResolver";
13import {OutputVerifier, PatternToFailure} from "../../common/outputVerifier";
14import {TelemetryHelper} from "../../common/telemetryHelper";
15import {CommandExecutor} from "../../common/commandExecutor";
16import {LogCatMonitor} from "./logCatMonitor";
17import {ReactNativeProjectHelper} from "../../common/reactNativeProjectHelper";
18
19/**
20 * Android specific platform implementation for debugging RN applications.
21 */
22export class AndroidPlatform extends GeneralMobilePlatform {
23 private static MULTIPLE_DEVICES_ERROR = "error: more than one device/emulator";
24
25 // We should add the common Android build/run errors we find to this list
26 private static RUN_ANDROID_FAILURE_PATTERNS: PatternToFailure[] = [{
27 pattern: "Failed to install on any devices",
28 message: "Could not install the app on any available device. Make sure you have a correctly"
29 + " configured device or emulator running. See https://facebook.github.io/react-native/docs/android-setup.html",
30 }, {
31 pattern: "com.android.ddmlib.ShellCommandUnresponsiveException",
32 message: "An Android shell command timed-out. Please retry the operation.",
33 }, {
34 pattern: "Android project not found",
35 message: "Android project not found.",
36
37 }, {
38 pattern: "error: more than one device/emulator",
39 message: AndroidPlatform.MULTIPLE_DEVICES_ERROR,
40 }, {
41 pattern: /^Error: Activity class \{.*\} does not exist\.$/m,
42 message: "Failed to launch the specified activity. Try running application manually and "
43 + "start debugging using 'Attach to packager' launch configuration.",
44 }];
45
46 private static RUN_ANDROID_SUCCESS_PATTERNS: string[] = ["BUILD SUCCESSFUL", "Starting the app", "Starting: Intent"];
47
48 private debugTarget: IDevice;
49 private devices: IDevice[];
50 private packageName: string;
51 private logCatMonitor: LogCatMonitor | null = null;
52
53 private needsToLaunchApps: boolean = false;
54 public static showDevMenu(deviceId?: string): Q.Promise<void> {
55 return AdbHelper.showDevMenu(deviceId);
56 }
57 public static reloadApp(deviceId?: string): Q.Promise<void> {
58 return AdbHelper.reloadApp(deviceId);
59 }
60
61 // We set remoteExtension = null so that if there is an instance of androidPlatform that wants to have it's custom remoteExtension it can. This is specifically useful for tests.
62 constructor(protected runOptions: IAndroidRunOptions, platformDeps: MobilePlatformDeps = {}) {
63 super(runOptions, platformDeps);
64
65 if (this.runOptions.target === AndroidPlatform.simulatorString ||
66 this.runOptions.target === AndroidPlatform.deviceString) {
67
68 const message = `Target ${this.runOptions.target} is not supported for Android ` +
69 "platform. If you want to use particular device or simulator for launching " +
70 "Android app, please specify device id (as in 'adb devices' output) instead.";
71
72 this.logger.warning(message);
73 delete this.runOptions.target;
74 }
75 }
76
77 public runApp(shouldLaunchInAllDevices: boolean = false): Q.Promise<void> {
78 return TelemetryHelper.generate("AndroidPlatform.runApp", () => {
79 const runArguments = this.getRunArgument();
80
81 return ReactNativeProjectHelper.getReactNativeVersion(this.runOptions.projectRoot)
82 .then(version => {
83 if (semver.gte(version, AndroidPlatform.NO_PACKAGER_VERSION)) {
84 runArguments.push("--no-packager");
85 }
86
87 const runAndroidSpawn = new CommandExecutor(this.projectPath, this.logger).spawnReactCommand("run-android", runArguments);
88 const output = new OutputVerifier(
89 () =>
90 Q(AndroidPlatform.RUN_ANDROID_SUCCESS_PATTERNS),
91 () =>
92 Q(AndroidPlatform.RUN_ANDROID_FAILURE_PATTERNS)).process(runAndroidSpawn);
93
94 return output
95 .finally(() => {
96 return this.initializeTargetDevicesAndPackageName();
97 }).then(() => [this.debugTarget], reason => {
98 if (reason.message === AndroidPlatform.MULTIPLE_DEVICES_ERROR && this.devices.length > 1 && this.debugTarget) {
99 /* If it failed due to multiple devices, we'll apply this workaround to make it work anyways */
100 this.needsToLaunchApps = true;
101 return shouldLaunchInAllDevices
102 ? AdbHelper.getOnlineDevices()
103 : Q([this.debugTarget]);
104 } else {
105 return Q.reject<IDevice[]>(reason);
106 }
107 }).then(devices => {
108 return new PromiseUtil().forEach(devices, device => {
109 return this.launchAppWithADBReverseAndLogCat(device);
110 });
111 });
112 });
113 });
114 }
115
116 public enableJSDebuggingMode(): Q.Promise<void> {
117 return AdbHelper.switchDebugMode(this.runOptions.projectRoot, this.packageName, true, this.debugTarget.id);
118 }
119
120 public disableJSDebuggingMode(): Q.Promise<void> {
121 return AdbHelper.switchDebugMode(this.runOptions.projectRoot, this.packageName, false, this.debugTarget.id);
122 }
123
124 public prewarmBundleCache(): Q.Promise<void> {
125 return this.packager.prewarmBundleCache("android");
126 }
127
128 public getRunArgument(): string[] {
129 let runArguments: string[] = [];
130
131 if (this.runOptions.runArguments && this.runOptions.runArguments.length > 0) {
132 runArguments = this.runOptions.runArguments;
133 } else {
134 if (this.runOptions.variant) {
135 runArguments.push("--variant", this.runOptions.variant);
136 }
137 if (this.runOptions.target) {
138 runArguments.push("--deviceId", this.runOptions.target);
139 }
140 }
141
142 return runArguments;
143 }
144
145 private initializeTargetDevicesAndPackageName(): Q.Promise<void> {
146 return AdbHelper.getConnectedDevices().then(devices => {
147 this.devices = devices;
148 this.debugTarget = this.getTargetEmulator(devices);
149 return this.getPackageName().then(packageName => {
150 this.packageName = packageName;
151 });
152 });
153 }
154
155 private launchAppWithADBReverseAndLogCat(device: IDevice): Q.Promise<void> {
156 return Q({})
157 .then(() => {
158 return this.configureADBReverseWhenApplicable(device);
159 }).then(() => {
160 return this.needsToLaunchApps
161 ? AdbHelper.launchApp(this.runOptions.projectRoot, this.packageName, device.id)
162 : Q<void>(void 0);
163 }).then(() => {
164 return this.startMonitoringLogCat(device, this.runOptions.logCatArguments);
165 });
166 }
167
168 private configureADBReverseWhenApplicable(device: IDevice): Q.Promise<void> {
169 return Q({}) // For other emulators and devices we try to enable adb reverse
170 .then(() => AdbHelper.apiVersion(device.id))
171 .then(apiVersion => {
172 if (apiVersion >= AndroidAPILevel.LOLLIPOP) { // If we support adb reverse
173 return AdbHelper.reverseAdb(device.id, Number( this.runOptions.packagerPort));
174 } else {
175 this.logger.warning(`Device ${device.id} supports only API Level ${apiVersion}. `
176 + `Level ${AndroidAPILevel.LOLLIPOP} is needed to support port forwarding via adb reverse. `
177 + "For debugging to work you'll need <Shake or press menu button> for the dev menu, "
178 + "go into <Dev Settings> and configure <Debug Server host & port for Device> to be "
179 + "an IP address of your computer that the Device can reach. More info at: "
180 + "https://facebook.github.io/react-native/docs/debugging.html#debugging-react-native-apps");
181 return void 0;
182 }
183 });
184 }
185
186 private getPackageName(): Q.Promise<string> {
187 return new Package(this.runOptions.projectRoot).name().then(appName =>
188 new PackageNameResolver(appName).resolvePackageName(this.runOptions.projectRoot));
189 }
190
191 /**
192 * Returns the target emulator, using the following logic:
193 * * If an emulator is specified and it is connected, use that one.
194 * * Otherwise, use the first one in the list.
195 */
196 private getTargetEmulator(devices: IDevice[]): IDevice {
197 let activeFilterFunction = (device: IDevice) => {
198 return device.isOnline;
199 };
200
201 let targetFilterFunction = (device: IDevice) => {
202 return device.id === this.runOptions.target && activeFilterFunction(device);
203 };
204
205 if (this.runOptions && this.runOptions.target && devices) {
206 /* check if the specified target is active */
207 const targetDevice = devices.find(targetFilterFunction);
208 if (targetDevice) {
209 return targetDevice;
210 }
211 }
212
213 /* return the first active device in the list */
214 let activeDevices = devices && devices.filter(activeFilterFunction);
215 return activeDevices && activeDevices[0];
216 }
217
218 private startMonitoringLogCat(device: IDevice, logCatArguments: string): void {
219 this.stopMonitoringLogCat(); // Stop previous logcat monitor if it's running
220
221 // this.logCatMonitor can be mutated, so we store it locally too
222 this.logCatMonitor = new LogCatMonitor(device.id, logCatArguments);
223 this.logCatMonitor.start() // The LogCat will continue running forever, so we don't wait for it
224 .catch(error => this.logger.warning("Error while monitoring LogCat", error)) // The LogCatMonitor failing won't stop the debugging experience
225 .done();
226 }
227
228 private stopMonitoringLogCat(): void {
229 if (this.logCatMonitor) {
230 this.logCatMonitor.dispose();
231 this.logCatMonitor = null;
232 }
233 }
234}
235