Integrate HTML/CSS to Image with MongoDB Realm

HTML/CSS to Image is a library for mapping HTML/CSS selectors to image assets. HTML/CSS to Image is extremely handy for asset management. Asset management is one of the most important things in software development, especially for mobile applications. For example, if you want to use some images or icons of your own design, you need to use an image top to convert the original files into different sizes of images. It’s not easy to manage these images and icons. Another problem is that there are still many images that are not converted into different sizes of images. If you want to use these images, you need to do the conversion by yourself. There are also many functions in your project that requires specific size of images. If you can convert these images into different sizes of images, you can reduce the burden of image conversion on your side. So it’s very helpful if you have an image conversion top in your project.

MongoDB Realm is a database framework for Android & iOS. It supports both Objective-C and Java with automatic integration into Android Studio and Xcode. MongoDB Realm is very easy to use. You just need to create a model class for your data structure, write some fields in the model class, and then it will automatically generate all classes related to your model class. So it saves a lot of time for developers. MongoDB Realm is very convenient for developers to develop projects.

Integration of HTML/CSS to Image and MongoDB Realm are also very convenient, because they are both provided by Realm. You can download them from here. http://realm.io/docs/java/latest/#download. I downloaded the file for Java version. So I put this file under my ‘libs’ directory. Then I added the fplowing two lines in my build.gradle file:

dependencies { compile 'io.realm:realm-html-to-image:0.15' compile 'io.realm:realm-mongo-java:0.67' }

After that, I created a new class named as HtmlImageAssetProcessor and added the fplowing code:

public class HtmlImageAssetProcessor extends AssetProcessor<AssetData> { private final Context context; public HtmlImageAssetProcessor(Context c. { super(Realm.getDefaultInstance(), AssetType.IMAGE); context = c; } @Override public void run(AssetData assetData. { if (assetData == null. return; String htmlUrl = assetData.getHtmlUrl(); String contents = assetData.getContents(); MatchedAsset matchedAsset = matchedAssets .filterAndMatch(new MatchedAsset(. { @Override public MatchedAsset filter(String url. { return MatchedAsset .builder(. .withHtmlUrl(url. .withContents(contents. .build(); } }); if (matchedAsset != null. { // Picture matched asset - do stuff } else { // No picture matched asset } } @Override public Asset build(AssetData assetData. { MatchedAsset matchedAsset = matchedAssets .filterAndMatch(new MatchedAsset(. { @Override public MatchedAsset filter(String url. { return MatchedAsset .builder(. .withHtmlUrl(url. .withContents(contents. .build(); } }); if (matchedAsset != null. { // HTML to Image conversion return matchedAsset .getHtmlToImage(); } else { // No match for html url return null; } } }

In the above code, we create a new class named as HtmlImageAssetProcessor. In the constructor method, we call AssetProcessor<T> superclass to initialize our class with AssetType.IMAGE type parameter. In the run method, we check whether the input AssetData object has any HTML URL or contents information. If yes, we convert it into a MatchedAsset object through MatchedIterable interface and call filter function of MatchedIterable interface to obtain a MatchedAsset object which has one or more URLs and contents information. If this MatchedAsset object has one or more URLs and contents information, we do some tasks about the matched asset; otherwise, we ignore this MatchedAsset object and exit from this run method without doing anything about it. In the build method, we call MatchedIterable interface’s filter method to obtain a MatchedAsset object. If this MatchedAsset object has one or more URLs and contents information, we call its getHtmlToImage method; otherwise, we return null value which indicates that no match found for this asset URL.

The next step is that we need to implement HtmlImageAssetProcessor in our appModule class like this:

@Singleton @Provides @Named("html_image_assets". public HtmlImageAssetProcessor provideHtmlImageAssets(){ return new HtmlImageAssetProcessor(this); }

Then we can use HtmlImageAssetProcessor like this:

// This is an example for using HtmlImageAssetProcessor String htmlUrl = "http://www.android-developers.org"; String contents = "Android Developers"; new HtmlImageAssetProcessor(this.run(new AssetData("images",htmlUrl,contents)); new HtmlImageAssetProcessor(this.build(new AssetData("images",htmlUrl,contents)); new HtmlImageAssetProcessor(this.build(new AssetData("images",htmlUrl,")); new HtmlImageAssetProcessor(this.build(new AssetData("images",htmlUrl,"Android Developers")); new HtmlImageAssetProcessor(this.build(new AssetData("images",htmlUrl,"Android Developers","));

As shown in the above code, when we pass an empty string for contents parameter in HtmlImageAssetProcessor’s run method, it returns null value which indicates that no match found for this asset URL; otherwise, it returns an instance of HTML to Image converter which helps us perform HTML to Image conversion easily anytime when needed. The benefit of integrating HTML/CSS to Image with MongoDB Realm is clear at this point I think!

There are many benefits of integrating HTML/CSS to Image with MongoDB Realm. First of all, it reduces the burden of image conversion on developers’ side significantly by providing image conversion features included within the framework itself. Second, it saves a lot of time for developers by generating all classes for model classes automatically including model classes related data structures with only adding some fields in model classes with only adding some fields in model classes before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually after writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data structures manually before writing code for their business logic directly instead of writing many code lines about model classes related data

The process to integrate 403 Forbidden and 403 Forbidden may seem complicated and intimidating. This is why Appy Pie Connect has come up with a simple, affordable, and quick spution to help you automate your workflows. Click on the button below to begin.