public void MergeFrom(VersionDetail other)
{
if (other == null)
{
return;
}
if (other.DataVersion.Length != 0)
{
DataVersion = other.DataVersion;
}
if (other.androidVersion_ != null)
{
if (androidVersion_ == null)
{
AndroidVersion = new global::gen.msg.VersionInfo();
}
AndroidVersion.MergeFrom(other.AndroidVersion);
}
if (other.iOSVersion_ != null)
{
if (iOSVersion_ == null)
{
IOSVersion = new global::gen.msg.VersionInfo();
}
IOSVersion.MergeFrom(other.IOSVersion);
}
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
}
public static string GenerateUserAgent(this AndroidDevice deviceInfo, InstaApiVersion apiVersion)
{
if (deviceInfo == null)
{
return(InstaApiConstants.UserAgentDefault);
}
if (deviceInfo.AndroidVer == null)
{
deviceInfo.AndroidVer = AndroidVersion.GetRandomAndriodVersion();
}
return(string.Format(
InstaApiConstants.UserAgent,
deviceInfo.Dpi,
deviceInfo.Resolution,
deviceInfo.HardwareManufacturer,
deviceInfo.DeviceModelIdentifier,
deviceInfo.FirmwareBrand,
deviceInfo.HardwareModel,
apiVersion.AppVersion,
deviceInfo.AndroidVer.ApiLevel,
deviceInfo.AndroidVer.VersionNumber,
apiVersion.AppApiVersionCode));
}
public override bool Execute()
{
Log.LogDebugMessage("CheckTargetFrameworks Task");
Log.LogDebugMessage(" TargetFrameworkVersion: {0}", TargetFrameworkVersion);
Log.LogDebugMessage(" ProjectFile: {0}", ProjectFile);
Log.LogDebugTaskItems(" ResolvedUserAssemblies: {0}", ResolvedAssemblies);
res = new DirectoryAssemblyResolver(Log.LogWarning, loadDebugSymbols: false);
foreach (var assembly in ResolvedAssemblies)
{
res.Load(Path.GetFullPath(assembly.ItemSpec));
var apiLevel = ExtractApiLevel(assembly);
if (apiLevel > 0)
{
Log.LogDebugMessage("{0}={1}", Path.GetFileNameWithoutExtension(assembly.ItemSpec), apiLevel);
apiLevels.Add(assembly, apiLevel);
}
}
var mainapiLevel = AndroidVersion.TryOSVersionToApiLevel(TargetFrameworkVersion);
foreach (var item in apiLevels.Where(x => mainapiLevel < x.Value))
{
var itemOSVersion = AndroidVersion.TryApiLevelToOSVersion(item.Value);
Log.LogWarning(null, "XA0105", null, ProjectFile, 0, 0, 0, 0,
"The $(TargetFrameworkVersion) for {0} (v{1}) is greater than the $(TargetFrameworkVersion) for your project ({2}). " +
"You need to increase the $(TargetFrameworkVersion) for your project.", Path.GetFileName(item.Key.ItemSpec), itemOSVersion, TargetFrameworkVersion);
}
return(!Log.HasLoggedErrors);
}
public ResponsResult SaveAndroid(AndroidVersion android)
{
ResponsResult result = new ResponsResult();
systemSettingService.SaveSettings(android);
return(result);
}
public void Load_NoFile()
{
Assert.Throws <ArgumentNullException> (() => AndroidVersion.Load((string)null));
var p = Path.GetTempFileName();
File.Delete(p);
Assert.Throws <FileNotFoundException> (() => AndroidVersion.Load(p));
}
public void SetViewHolder(AndroidVersion androidVersion)
{
var imageAsBytes = Base64.Decode(androidVersion.Image, Base64Flags.Default);
var imageAsBitmap = BitmapFactory.DecodeByteArray(imageAsBytes, 0, imageAsBytes.Length);
ImageViewIcon.SetImageBitmap(imageAsBitmap);
TextViewName.Text = androidVersion.Name;
TextViewVersion.Text = androidVersion.Version;
}
public void Constructor()
{
var v = new AndroidVersion(apiLevel: 1, osVersion: "2.3", codeName: "Four", id: "E", stable: false);
Assert.AreEqual(1, v.ApiLevel);
Assert.AreEqual("E", v.Id);
Assert.AreEqual("Four", v.CodeName);
Assert.AreEqual("2.3", v.OSVersion);
Assert.AreEqual(new Version(2, 3), v.TargetFrameworkVersion);
Assert.AreEqual("v2.3", v.FrameworkVersion);
Assert.AreEqual(false, v.Stable);
}
public static string GenerateUserAgent(this AndroidDevice deviceInfo)
{
if (deviceInfo == null)
{
return(InstaApiConstants.USER_AGENT_DEFAULT);
}
if (deviceInfo.AndroidVer == null)
{
deviceInfo.AndroidVer = AndroidVersion.GetRandomAndriodVersion();
}
return(string.Format(InstaApiConstants.USER_AGENT, deviceInfo.Dpi, deviceInfo.Resolution, deviceInfo.HardwareManufacturer,
deviceInfo.DeviceModelIdentifier, deviceInfo.FirmwareBrand, deviceInfo.HardwareModel,
InstaApiConstants.IG_APP_VERSION, deviceInfo.AndroidVer.APILevel,
deviceInfo.AndroidVer.VersionNumber, InstaApiConstants.IG_APP_API_VERSION));
}
Version GetJavaVersionForFramework(string targetFrameworkVersion)
{
var apiLevel = AndroidVersion.TryOSVersionToApiLevel(targetFrameworkVersion);
if (apiLevel >= 24)
{
return(new Version(1, 8));
}
else if (apiLevel == 23)
{
return(new Version(1, 7));
}
else
{
return(new Version(1, 6));
}
}
public void Load()
{
var xml = @"<AndroidApiInfo>
<Id>O</Id>
<Level>26</Level>
<Name>Android O</Name>
<Version>v7.99.0</Version>
<Stable>False</Stable>
</AndroidApiInfo>";
var v = AndroidVersion.Load(new MemoryStream(Encoding.UTF8.GetBytes(xml)));
Assert.AreEqual(26, v.ApiLevel);
Assert.AreEqual("O", v.Id);
Assert.AreEqual("Android O", v.CodeName);
Assert.AreEqual("7.99.0", v.OSVersion);
Assert.AreEqual(new Version(7, 99, 0), v.TargetFrameworkVersion);
Assert.AreEqual("v7.99.0", v.FrameworkVersion);
Assert.AreEqual(false, v.Stable);
}
int ExtractApiLevel(ITaskItem ass)
{
Log.LogDebugMessage(ass.ItemSpec);
foreach (var ca in res.GetAssembly(ass.ItemSpec).CustomAttributes)
{
switch (ca.AttributeType.FullName)
{
case "System.Runtime.Versioning.TargetFrameworkAttribute":
foreach (var p in ca.ConstructorArguments)
{
var value = p.Value.ToString();
if (value.StartsWith("MonoAndroid"))
{
var values = value.Split('=');
return(AndroidVersion.TryOSVersionToApiLevel(values[1]));
}
}
break;
}
}
return(0);
}
public override int GetHashCode()
{
int hash = 1;
if (DataVersion.Length != 0)
{
hash ^= DataVersion.GetHashCode();
}
if (androidVersion_ != null)
{
hash ^= AndroidVersion.GetHashCode();
}
if (iOSVersion_ != null)
{
hash ^= IOSVersion.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public UniversalDevice()
{
var rnd = new Random();
EasClientDeviceInformation deviceInfo = new EasClientDeviceInformation();
var deviceGuid = deviceInfo.Id;
AndroidVer = AndroidVersion.GetAndroid9();
DeviceGuid = deviceGuid;
DeviceId = ApiRequestMessage.GenerateDeviceIdFromGuid(deviceGuid);
PhoneGuid = GetPhoneGuid(deviceGuid);
FamilyDeviceGuid = GetFamilyDeviceGuid(deviceGuid);
PushDeviceGuid = GetPushDeviceGuid(deviceGuid);
PigeonSessionId = GetPigeonSessionId(deviceGuid);
IGBandwidthSpeedKbps = $"{rnd.Next(1233, 1567).ToString(CultureInfo.InvariantCulture)}.{rnd.Next(100, 999).ToString(CultureInfo.InvariantCulture)}";
IGBandwidthTotalTimeMS = rnd.Next(781, 999).ToString(CultureInfo.InvariantCulture);
try
{
IGBandwidthTotalBytesB = ((int)((double.Parse(IGBandwidthSpeedKbps, CultureInfo.InvariantCulture) * double.Parse(IGBandwidthTotalTimeMS, CultureInfo.InvariantCulture)) + rnd.Next(100, 999))).ToString();
}
catch { }
var deviceModel = GetDeviceModelIfPossible(deviceInfo.SystemProductName);
var displayInfo = DisplayInformation.GetForCurrentView();
var dpi = displayInfo.LogicalDpi + "dpi";
var height = displayInfo.ScreenHeightInRawPixels;
var width = displayInfo.ScreenWidthInRawPixels;
var resolution = height < width ? $"{height}x{width}" : $"{width}x{height}";
var id = deviceGuid.ToString().Split('-')[1];
AndroidBoardName = GetBoardNameIfPossible(deviceInfo.SystemProductName);
DeviceBrand = deviceInfo.SystemManufacturer;
HardwareManufacturer = deviceInfo.SystemManufacturer;
DeviceModel = deviceModel;
DeviceModelIdentifier = deviceModel;
FirmwareBrand = GetFirmwareBrandIfPossible(deviceInfo.SystemProductName);
Resolution = resolution;
Dpi = dpi;
HardwareModel = id.Substring(1, 2) + id.Substring(2) + id.Substring(0, 2);
}
void SetAndroidVersion()
{
if (AndroidVersion.Equals("JellyBean"))
{
AndroidVersionForRequest = "AV052";
}
else if (AndroidVersion.Equals("Lollipop"))
{
AndroidVersionForRequest = "AV0L0";
}
else
{
//Some devices (Intel ?) need specific version
if (DeviceName.Equals("A1-840FHD") || DeviceName.Equals("A1-724") ||
DeviceName.Equals("A1-840"))
{
AndroidVersionForRequest = "AV0K1";
}
else
{
AndroidVersionForRequest = "AV0K0";
}
}
}
public ResponsResult SaveAndroid([FromBody] AndroidVersion android)
{
return(_commonService.SaveAndroid(android));
}
public void Load_NoStream()
{
Assert.Throws <ArgumentNullException> (() => AndroidVersion.Load((Stream)null));
}
private async void DoVersionClicked(AndroidVersion version)
{
var parameter = new NavigationParameters($"id={version.ID}");
await navigationService.NavigateAsync("DetailPageView", parameter);
}
/// <summary>
/// Configure photo
/// </summary>
/// <param name="image">Photo to configure</param>
/// <param name="uploadId">Upload id</param>
/// <param name="caption">Caption</param>
/// <returns></returns>
private async Task <IResult <InstaMedia> > ConfigurePhotoAsync(InstaImage image, string uploadId, string caption)
{
try
{
var instaUri = UriCreator.GetMediaConfigureUri();
var androidVersion =
AndroidVersion.FromString(_deviceInfo.FirmwareFingerprint.Split('/')[2].Split(':')[1]);
if (androidVersion == null)
{
return(Result.Fail("Unsupported android version", (InstaMedia)null));
}
var data = new JObject
{
{ "_uuid", _deviceInfo.DeviceGuid.ToString() },
{ "_uid", _user.LoggedInUser.Pk },
{ "_csrftoken", _user.CsrfToken },
{ "media_folder", "Camera" },
{ "source_type", "4" },
{ "caption", caption },
{ "upload_id", uploadId },
{
"device", new JObject
{
{ "manufacturer", _deviceInfo.HardwareManufacturer },
{ "model", _deviceInfo.HardwareModel },
{ "android_version", androidVersion.VersionNumber },
{ "android_release", androidVersion.APILevel }
}
},
{
"edits", new JObject
{
{ "crop_original_size", new JArray {
image.Width, image.Height
} },
{ "crop_center", new JArray {
0.0, -0.0
} },
{ "crop_zoom", 1 }
}
},
{
"extra", new JObject
{
{ "source_width", image.Width },
{ "source_height", image.Height }
}
}
};
var request = HttpHelper.GetSignedRequest(HttpMethod.Post, instaUri, _deviceInfo, data);
var response = await _httpRequestProcessor.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
return(Result.UnExpectedResponse <InstaMedia>(response, json));
}
var mediaResponse =
JsonConvert.DeserializeObject <InstaMediaItemResponse>(json, new InstaMediaDataConverter());
var converter = ConvertersFabric.Instance.GetSingleMediaConverter(mediaResponse);
return(Result.Success(converter.Convert()));
}
catch (Exception exception)
{
_logger?.LogException(exception);
return(Result.Fail <InstaMedia>(exception));
}
}
private async Task <IResult <InstaMedia> > ConfigureVideoAsync(InstaVideo video, string uploadId, string caption)
{
try
{
var instaUri = UriCreator.GetMediaConfigureUri();
var androidVersion =
AndroidVersion.FromString(_deviceInfo.FirmwareFingerprint.Split('/')[2].Split(':')[1]);
if (androidVersion == null)
{
return(Result.Fail("Unsupported android version", (InstaMedia)null));
}
var data = new JObject
{
{ "caption", caption },
{ "upload_id", uploadId },
{ "source_type", "3" },
{ "camera_position", "unknown" },
{
"extra", new JObject
{
{ "source_width", video.Width },
{ "source_height", video.Height }
}
},
{
"clips", new JArray {
new JObject
{
{ "length", 10.0 },
{ "creation_date", DateTime.Now.ToString("yyyy-dd-MMTh:mm:ss-0fff") },
{ "source_type", "3" },
{ "camera_position", "back" }
}
}
},
{ "poster_frame_index", 0 },
{ "audio_muted", false },
{ "filter_type", "0" },
{ "video_result", "deprecated" },
{ "_csrftoken", _user.CsrfToken },
{ "_uuid", _deviceInfo.DeviceGuid.ToString() },
{ "_uid", _user.LoggedInUser.UserName }
};
var request = HttpHelper.GetSignedRequest(HttpMethod.Post, instaUri, _deviceInfo, data);
request.Headers.Host = "i.instagram.com";
var response = await _httpRequestProcessor.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
return(Result.UnExpectedResponse <InstaMedia>(response, json));
}
var success = await ExposeVideoAsync(uploadId);
if (success.Succeeded)
{
return(Result.Success(success.Value));
}
else
{
return(Result.Fail <InstaMedia>("Cannot expose media"));
}
}
catch (Exception exception)
{
_logger?.LogException(exception);
return(Result.Fail <InstaMedia>(exception));
}
}
protected override void Execute(NativeActivityContext context)
{
// Gather fields
string apkPath = ApkPath.Get(context);
string deviceName = DeviceName.Get(context);
string version = AndroidVersion.Get(context);
string package = AppPackage.Get(context);
string activity = AppActivity.Get(context);
string locale = Locale.Get(context) ?? "US";
string language = Language.Get(context) ?? "en";
int waitTime = WaitTime.Get(context);
string screenshotPath = ScreenshotPath.Get(context) ?? "";
string chromedriverPath = ChromedriverPath.Get(context) ?? "";
// Initialize Driver and Appium Server
AndroidDriver <AndroidElement> driver;
AppiumLocalService server;
// Start Appium Server on any open port
server = new AppiumServiceBuilder().UsingAnyFreePort().Build();
server.Start();
// Set additional capabilities
var options = new AppiumOptions();
//Device capabilities
options.AddAdditionalCapability(MobileCapabilityType.DeviceName, deviceName);
options.AddAdditionalCapability(MobileCapabilityType.PlatformName, "Android");
options.AddAdditionalCapability(MobileCapabilityType.PlatformVersion, version);
options.AddAdditionalCapability(MobileCapabilityType.Locale, locale);
options.AddAdditionalCapability(MobileCapabilityType.Language, language);
// Use UIAutomator2 for better performance
options.AddAdditionalCapability(MobileCapabilityType.AutomationName, AutomationName.AndroidUIAutomator2);
// Launch App or Browser depending on user input
switch (LaunchType)
{
case LaunchType.App:
// App capabilities
if (!String.IsNullOrEmpty(apkPath))
{
options.AddAdditionalCapability(MobileCapabilityType.App, apkPath);
}
options.AddAdditionalCapability(AndroidMobileCapabilityType.AppPackage, package);
options.AddAdditionalCapability(AndroidMobileCapabilityType.AppActivity, activity);
break;
case LaunchType.Browser:
// Browser capabilities
switch (BrowserType)
{
case BrowserType.Chrome:
options.AddAdditionalCapability(MobileCapabilityType.BrowserName, MobileBrowserType.Chrome);
if (!String.IsNullOrEmpty(chromedriverPath))
{
options.AddAdditionalCapability(AndroidMobileCapabilityType.ChromedriverExecutable, chromedriverPath);
}
break;
default:
throw new ArgumentNullException("Missing Argument: BrowserType.");
}
break;
default:
throw new ArgumentNullException("Missing Argument: LaunchType.");
}
// Default Screenshot Path
options.AddAdditionalCapability(AndroidMobileCapabilityType.AndroidScreenshotPath, screenshotPath);
driver = new AndroidDriver <AndroidElement>(server, options);
driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(waitTime);
// Export driver
Driver.Set(context, driver);
// Schedule Activities
if (Body != null)
{
context.ScheduleAction <AndroidDriver <AndroidElement> >(Body, driver, OnCompleted, OnFaulted);
}
}
