bool BuildBase::BuildClean(const String& path)
{
if (buildFailed_)
{
LOGERRORF("BuildBase::BuildClean - Attempt to clean directory of failed build, %s", path.CString());
return false;
}
FileSystem* fileSystem = GetSubsystem<FileSystem>();
if (!fileSystem->DirExists(path))
return true;
// On Windows, do a little dance with the folder to avoid issues
// with deleting folder and immediately recreating it
String pathName, fileName, ext;
SplitPath(path, pathName, fileName, ext);
pathName = AddTrailingSlash(pathName);
unsigned i = 0;
while (true)
{
String newPath = ToString("%s%s_Temp_%u", pathName.CString(), fileName.CString(), i++);
if (!fileSystem->DirExists(newPath))
{
if (!MoveFileExW(GetWideNativePath(path).CString(), GetWideNativePath(newPath).CString(), MOVEFILE_WRITE_THROUGH))
{
FailBuild(ToString("BuildBase::BuildClean: Unable to move directory %s -> ", path.CString(), newPath.CString()));
return false;
}
// Remove the moved directory
return BuildRemoveDirectory(newPath);
}
else
{
LOGWARNINGF("BuildBase::BuildClean - temp build folder exists, removing: %s", newPath.CString());
fileSystem->RemoveDir(newPath, true);
}
if (i == 255)
{
FailBuild(ToString("BuildBase::BuildClean: Unable to move directory ( i == 255) %s -> ", path.CString(), newPath.CString()));
return false;
}
}
return false;
}
void BuildAndroid::RunADBStartActivity()
{
SubprocessSystem* subs = GetSubsystem<SubprocessSystem>();
String adbCommand = platformAndroid_->GetADBCommand();
ToolSystem* toolSystem = GetSubsystem<ToolSystem>();
Project* project = toolSystem->GetProject();
AndroidBuildSettings* settings = project->GetBuildSettings()->GetAndroidBuildSettings();
String stringArgs;
const char* cpackage = settings->GetPackageName().CString();
stringArgs.AppendWithFormat("shell am start -n %s/%s.AtomicGameEngine",cpackage, cpackage);
Vector<String> args = stringArgs.Split(' ');
currentBuildPhase_ = ADBStartActivity;
Subprocess* subprocess = subs->Launch(adbCommand, args, buildPath_);
if (!subprocess)
{
FailBuild("StartActivity operation did not launch successfully.");
return;
}
VariantMap buildOutput;
buildOutput[BuildOutput::P_TEXT] = "\n\n<color #D4FB79>Starting Android Activity</color>\n\n";
SendEvent(E_BUILDOUTPUT, buildOutput);
SubscribeToEvent(subprocess, E_SUBPROCESSCOMPLETE, ATOMIC_HANDLER(BuildAndroid, HandleADBStartActivityComplete));
SubscribeToEvent(subprocess, E_SUBPROCESSOUTPUT, ATOMIC_HANDLER(BuildBase, HandleSubprocessOutputEvent));
}
void BuildAndroid::RunADBListDevices()
{
ToolSystem* toolSystem = GetSubsystem<ToolSystem>();
SubprocessSystem* subs = GetSubsystem<SubprocessSystem>();
String adbCommand = platformAndroid_->GetADBCommand();
deviceListText_.Clear();
Vector<String> args = String("devices").Split(' ');
currentBuildPhase_ = ADBListDevices;
Subprocess* subprocess = subs->Launch(adbCommand, args, "");
if (!subprocess)
{
FailBuild("Android List Device operation did not launch successfully.");
return;
}
VariantMap buildOutput;
buildOutput[BuildOutput::P_TEXT] = "\n\n<color #D4FB79>Listing Android Devices</color>\n\n";
SendEvent(E_BUILDOUTPUT, buildOutput);
SubscribeToEvent(subprocess, E_SUBPROCESSCOMPLETE, ATOMIC_HANDLER(BuildAndroid, HandleADBListDevicesComplete));
SubscribeToEvent(subprocess, E_SUBPROCESSOUTPUT, ATOMIC_HANDLER(BuildAndroid, HandleADBListDevicesOutputEvent));
}
void BuildAndroid::RunADBInstall()
{
ToolEnvironment* tenv = GetSubsystem<ToolEnvironment>();
ToolPrefs* prefs = tenv->GetToolPrefs();
SubprocessSystem* subs = GetSubsystem<SubprocessSystem>();
String adbCommand = platformAndroid_->GetADBCommand();
Vector<String> args;
if ( prefs->GetReleaseCheck() > 2 ) // install release apk
args = String("install -r ./bin/Atomic-release.apk").Split(' ');
else
args = String("install -r ./bin/Atomic-debug.apk").Split(' ');
currentBuildPhase_ = ADBInstall;
Subprocess* subprocess = subs->Launch(adbCommand, args, buildPath_);
if (!subprocess)
{
FailBuild("APK Device Installation operation did not launch successfully.");
return;
}
VariantMap buildOutput;
buildOutput[BuildOutput::P_TEXT] = "\n\n<color #D4FB79>Installing on Android Device</color>\n\n";
SendEvent(E_BUILDOUTPUT, buildOutput);
SubscribeToEvent(subprocess, E_SUBPROCESSCOMPLETE, ATOMIC_HANDLER(BuildAndroid, HandleRunADBInstallComplete));
SubscribeToEvent(subprocess, E_SUBPROCESSOUTPUT, ATOMIC_HANDLER(BuildBase, HandleSubprocessOutputEvent));
}
bool BuildWindows::BuildManaged(const String& buildPath)
{
ToolEnvironment* tenv = GetSubsystem<ToolEnvironment>();
ToolSystem* toolSystem = GetSubsystem<ToolSystem>();
FileSystem* fileSystem = GetSubsystem<FileSystem>();
Project* project = toolSystem->GetProject();
ProjectSettings* settings = project->GetProjectSettings();
String projectPath = project->GetProjectPath();
#ifdef ATOMIC_DEBUG
String config = "Debug";
#else
String config = "Release";
#endif
String managedBins = projectPath + ToString("AtomicNET/%s/Bin/Desktop/", config.CString());
String managedExe = managedBins + settings->GetName() + ".exe";
if (!fileSystem->FileExists(managedExe))
{
FailBuild(ToString("Error building managed project, please compile the %s binary %s before building", config.CString(), managedExe.CString()));
return false;
}
StringVector results;
StringVector filtered;
fileSystem->ScanDir(results, managedBins, "", SCAN_FILES, false);
StringVector filterList;
StringVector::Iterator itr = results.Begin();
while (itr != results.End())
{
unsigned i;
for (i = 0; i < filterList.Size(); i++)
{
if (itr->Contains(filterList[i]))
break;
}
if (i == filterList.Size())
filtered.Push(*itr);
itr++;
}
for (unsigned i = 0; i < filtered.Size(); i++)
{
String filename = filtered[i];
if (!BuildCopyFile(managedBins + filename, buildPath_ + "/" + filename))
return false;
}
return true;
}
bool BuildBase::BuildCopyFile(const String& srcFileName, const String& destFileName)
{
if (buildFailed_)
{
LOGERRORF("BuildBase::BuildCopyFile - Attempt to copy file of failed build, %s", srcFileName.CString());
return false;
}
FileSystem* fileSystem = GetSubsystem<FileSystem>();
bool result = fileSystem->Copy(srcFileName, destFileName);
if (!result)
{
FailBuild(ToString("BuildBase::BuildCopyFile: Unable to copy file %s -> %s", srcFileName.CString(), destFileName.CString()));
return false;
}
return true;
}
bool BuildBase::BuildRemoveDirectory(const String& path)
{
if (buildFailed_)
{
LOGERRORF("BuildBase::BuildRemoveDirectory - Attempt to remove directory of failed build, %s", path.CString());
return false;
}
FileSystem* fileSystem = GetSubsystem<FileSystem>();
if (!fileSystem->DirExists(path))
return true;
bool result = fileSystem->RemoveDir(path, true);
if (!result)
{
FailBuild(ToString("BuildBase::BuildRemoveDirectory: Unable to remove directory %s", path.CString()));
return false;
}
return true;
}
void BuildAndroid::Build(const String& buildPath)
{
ToolEnvironment* tenv = GetSubsystem<ToolEnvironment>();
ToolSystem* tsystem = GetSubsystem<ToolSystem>();
Project* project = tsystem->GetProject();
buildPath_ = AddTrailingSlash(buildPath) + GetBuildSubfolder();
Initialize();
if (!BuildClean(buildPath_))
return;
//generate manifest file
String manifest;
for (unsigned i = 0; i < resourceEntries_.Size(); i++)
{
BuildResourceEntry* entry = resourceEntries_[i];
manifest += entry->packagePath_;
if ( i != resourceEntries_.Size() - 1)
manifest += ";";
}
String buildSourceDir = tenv->GetToolDataDir();
String androidProject = buildSourceDir + "Deployment/Android";
// Copy the base android project
FileSystem* fileSystem = GetSubsystem<FileSystem>();
if( !BuildCopyDir(androidProject, buildPath_))
return;
Vector<String> defaultResourcePaths;
GetDefaultResourcePaths(defaultResourcePaths);
String projectResources = project->GetResourcePath();
for (unsigned i = 0; i < defaultResourcePaths.Size(); i++)
{
if ( !BuildCopyDir(defaultResourcePaths[i], buildPath_ + "/assets/" + GetFileName(RemoveTrailingSlash(defaultResourcePaths[i]))))
return;
}
if( !BuildCopyDir(project->GetProjectPath() + "Cache/", buildPath_ + "/assets/Cache"))
return;
if( !BuildCopyDir(projectResources, buildPath_ + "/assets/AtomicResources"))
return;
// write the manifest
SharedPtr<File> mfile(new File(context_, buildPath_ + "/assets/AtomicManifest", FILE_WRITE));
mfile->WriteString(manifest);
mfile->Close();
//check for Deployment/Android/libs/armeabi-v7a/libAtomicPlayer.so
if ( !fileSystem->FileExists(androidProject + "/libs/armeabi-v7a/libAtomicPlayer.so") )
{
FailBuild( "The file libAtomicPlayer.so is not found. This is required for APK generation." );
return;
}
AndroidProjectGenerator gen(context_, this);
gen.SetBuildPath(buildPath_);
if (!gen.Generate())
{
FailBuild(gen.GetErrorText());
return;
}
RunAntDebug();
}
void BuildAndroid::RunAntDebug()
{
ToolEnvironment* tenv = GetSubsystem<ToolEnvironment>();
SubprocessSystem* subs = GetSubsystem<SubprocessSystem>();
ToolPrefs* tprefs = tenv->GetToolPrefs();
Poco::Process::Env env;
String buildApk = "debug"; // the default
if ( tprefs->GetReleaseCheck() > 2 ) // create release apk
buildApk = "release";
#ifdef ATOMIC_PLATFORM_OSX
String antCommand = tprefs->GetAntPath();
Vector<String> args;
args.Push(buildApk);
#endif
#ifdef ATOMIC_PLATFORM_WINDOWS
// C:\ProgramData\Oracle\Java\javapath;
Vector<String> args;
String antCommand = "cmd";
String antPath = tprefs->GetAntPath() + "/ant.bat";
env["JAVA_HOME"] = tprefs->GetJDKRootPath().CString();
// ant is a batch file on windows, so have to run with cmd /c
args.Push("/c");
args.Push("\"" + antPath + "\"");
args.Push(buildApk);
#endif
#ifdef ATOMIC_PLATFORM_LINUX
String antCommand = tprefs->GetAntPath();
if ( antCommand.Empty() ) // user didnt fill it out, use installed one
{
antCommand = "/usr/bin/ant"; // system default if installed
}
else
{
antCommand.Append("/ant");
}
FileSystem* fileSystem = GetSubsystem<FileSystem>();
if ( !fileSystem->FileExists ( antCommand) )
{
FailBuild("The ant program can not be found, check the Ant Path in Build Settings.");
}
Vector<String> args;
args.Push(buildApk);
#endif
currentBuildPhase_ = AntBuildDebug;
Subprocess* subprocess = subs->Launch(antCommand, args, buildPath_, env);
if (!subprocess)
{
FailBuild("The ant build operation did not launch successfully.");
return;
}
VariantMap buildOutput;
buildOutput[BuildOutput::P_TEXT] = "<color #D4FB79>Starting Android " + buildApk + " Deployment</color>\n\n";
SendEvent(E_BUILDOUTPUT, buildOutput);
SubscribeToEvent(subprocess, E_SUBPROCESSCOMPLETE, ATOMIC_HANDLER(BuildAndroid, HandleAntDebugComplete));
SubscribeToEvent(subprocess, E_SUBPROCESSOUTPUT, ATOMIC_HANDLER(BuildBase, HandleSubprocessOutputEvent));
}
