* Upgraded a good few things
- multitargeting for netstandard1.3, netstandard2.0, netcoreapp3.0 and net45
- iOS, tvOS, macOS, watchOS now builds on non-macOS (not embedded binaries)
- removed empty assembly infos
- using Directory.Build.* to clean up a few things
- improved the msbuild tasks to properly skip
* Add the targets file to the nuget
* Let all the tests run before failing the build
* Pack and validate in one go
* Update the samples to use the new projects
* Use VS 2017 for native builds for now
* Update Dockerfiles
* removed references from Views.WPF to OpenTK #1029 (#1078)
* Install the type redirector
* Update depot_tools
* Don't do any signing for macOS
Co-authored-by: Tyson Williams <34664007+bender2k14@users.noreply.github.com>
* Update the NuGet versions
* Improve the DevOps build number
* Extract the variable logic from the yaml
* Use Docker to build, and update to Ubuntu 16
* Some of the colorspaces created are just references
- SRGB and SRGB Linear colorspaces are static and should never be disposed
* Fix concurrent disposal and creation
- In some cases, a new native object is created with the same memory location while the
managed instances is still being disposed. In this case, we cannot remove the managed
instance from the dictionary, since it is not the current object being disposed anymore.
- SKColorSpace has some members that should not be disposed, since they are static on the
native side. Just, there is no docs for this, so calling dispose will crash everything.
- Added the logic to make sure that all static objects are created before anything, so we can
get a handle on them and make sure they are static managed instances.
* Make sure the objects are not collected when using spans
Changes:
- Added `GCHandleProxy` to debug builds
- this is used to track all `GCHandle` `Alloc` and `Free` calls to ensure that all allocations are freed.
- added some unit tests to make sure this is actually enforced
- as a result, several object are now freed correctly
- Added `ISKReferenceCounted` and `ISKNonVirtualReferenceCounted` interfaces to represent the reference counting types used in the native library
- this helps with automatically de-referencing objects
- `SKAbstractManagedStream`, `SKAbstractManagedWStream` and `SKDrawable` have been re-written to use better delegates
- instead of passing each of the delegates as parameters, they are now a struct that is passed as a single object
- better for extensions (which there shouldn't be) and only a single static field on the type
- removed the usage of `Marshal.GetFunctionPointerForDelegate`, which should help out with WASM (see #876)
- the objects now only keep weak references, meaning that they can now be garbage collected
- instead of trying to resolve the instances with a dictionary, a delegate is used and passed as "user context"
- Moved some of the repetitive logic from the types into the base `SKObject` and `SKNativeObject`
- some logic is automatically executed if the concrete type is `ISKReferenceCounted` or `ISKNonVirtualReferenceCounted`
- with the more centralized logic and stricter patterns, better tests can be written to make sure all memory is freed correctly and timely
- `SKData`, `SKFontManager` and `SKTypeface` now correctly prevent disposal of the "static" instances
- `SKPaint` now references the `Shader`, `MaskFilter`, `ColorFilter`, `ImageFilter`, `Typeface` and `PathEffect` properties
- this prevents accidental collection, or non-collection when the object goes out of scope
- the `SKPath` iterators (`Iterator` and `RawIterator`) and op builder (`OpBuilder`) now correctly own and dispose their native objects
- `SKRegion` objects are now disposed on the native side
- `SKTypeface` construction from a `SKManagedStream` (via both `SKTypeface` and `SKFontManager`) now copy the contents of the .NET `Stream` into a native memory
- typeface construction requires multiple seeks (previously, the stream was copied only if it was non-seekable)
- it also requires "duplicating" the stream, which is not supported on .NET streams
- duplicates or forks of a stream means that each of the streams need to be read concurrently from different locations
- .NET streams can only have a single position
- Updated the NuGets used for the tests
- using the `Xunit.AssemblyFixture` and `Xunit.SkippableFact` NuGets instead of using the code directly
- removed the `Xunit.Categories` NuGet as it was preventing tests from running
This PR has a big set of changes that may be breaking due to bug fixes:
- The `SKAbstractManagedStream`, `SKAbstractManagedWStream` and `SKDrawable` no longer prevent the GC from collecting them. This means that if code no longer references them, they will be disposed.
- As far as I can tell, this should not be a problem for the streams as they are never kept around - they are just used for reading and writing and typically only need to live for as long as a single method, and then need to be disposed by the caller. The `SKTypeface` and `SKDocument` do keep it around for a bit, but then they also take ownership of the stream and keep a hard reference to the streams themselves. They will dispose the streams when they are disposed.
- `SKDrawable` is never kept around and is entirely a user-controlled object. If it goes out of scope, skia doesn't have a reference anyway.
- The `SKFontManager` and `SKTypeface` no longer use the managed streams (`SKManagedStream` or `Stream`) directly
- they make a copy.
- This is simply because skia streams can do things that are not possible for .NET - they can be read concurrently from different positions. If a `SKFileStream` or `SKMemoryStream` are passed, then the streams are not copied.
- Further optimizations can be made in the case of a `MemoryStream` or `byte[]` to not actually copy but use GC pinning to get a handle to the managed data and work with pointers. But this can be done later so that this PR can be merged and tested.
Add a new NuGet
- add a targets file to the nuget to warn if the platform packages were not installed
Update the pipeline:
- use build artifacts everywhere
- just disable tizen for Windows
* Removed v2.3.1 and renamed Flags to BufferFlags
* Updated some API and Doc
* Add Gtk3 views
* Reworked the samples logic
- handle the more varied project structure
- build the generated zip to test it
- always use the local nuget cache
* macOS is always Any CPU
* Rename SKWidget to SKDrawingArea for GTK#3
- this allows us to have a single moniker for docs
- it indicates that it is not quite the same as the widget in GTK#2
- is is more specific so we can have more GTK# controls
* merge all the views (except forms) into a single moniker so it is better for browsing in the docs portal
* SK3dView is not actually obsolete :)
* Add readmes to the samples
- `dotnet build` will fail because `CodeTaskFactory` factory is not supported, so use regular MSBuild properties
- use the new stages feature
- .net core tests now use libraries instead of nugets
- changed a few things in the pipeline yaml
* Remove the environment variables from the yaml
* Remove the Java bits from the tizen script
* Add the java bin to PATH
* Set the ANDROID_NDK_HOME variable
* Set the TIZEN_STUDIO_HOME variable
* Use a variable for the host vm image
* Add a retry option for the tests because they fail sometimes
* Removing the samples temporarily as they are failing to build
* Updating cake and the bootstrappers
- Adding the signing logic
- Don't checkout on signing
- add features support
- Adding some user-friendly names
- Adding a build counter tied to the branch
Refactor the pipeline to reuse most of the functionality
- typically, just the target changes
- added hooks for pre/post build steps for the special cases
- rewrote the scripts using powershell only
* Trying to get an older linux build
* Switch to clang 3.8 on linux. #686
* Statically link things for linux
* Set up CI with Azure Pipelines
* Updated the tizen install script to work on macos and linux
* Make sure to install the version of the Android NDK we support
* Added missing [SkippableFact] attribute
Matthew Leibowitz
Xamarin Release Engineering