I have 2 apps, one for the clients and one for the managers. They are based on similar code (Classes, Layouts, Activities).
How do I "share" those files between the 2 apps? So if I change a shared class or a layout, the change would be visible in both apps. (So I make only ONE change, and not have to make two).
I work on Android Studio.
Thank you.
Here is an excellent discussion about sharing code: StackOverFlow #24592027 I'm doing a pair of apps for Wear and Phone products and the Android docs recommend to build both in the same project file as separate modules. Based on the comments in the link, I created a third Module called 'sharedcode' that I can then link between the Wear and Phone apps. This give me a common shared code module. I think the point is that your two apps will also need to be combined into a single project. Each app gets its own compilation target, but they then both share the same code.
Then go into the dependency settings (File | Project Structure; tab to Dependencies) and set each app to depend on the SharedCode module. Good luck.
Related
I am attempting to develop a Wear OS app which is dependent on a paired Android phone to perform some higher complexity computations. To this end I have implemented on the wearable side the proper infrastructure to pass a PutDataMapRequest message to the phone app, where I am having trouble is extending the WearableListenerService class on the phone side. When I alt+enter to see the suggested actions menu, the option to add the requisite library is there. However when I select that option nothing happens and the option is still there afterwards (the error is not rectified). I will caveat this by saying I have only been developing for Android for about 2 weeks so some of this Android Studio and its' quirks are still a little new to me. Prior to this point I had attempted various incarnations of building this app. The first where I had built the apps separately, and on that attempt this same extension caused problems (the IDE didn't even offer any suggestions at that point). I also tried loading the data layer api sample to find an example of the wearable listener service but unfortunately it is only present on the wear side of the app. The original source of this approach was from this tutorial, which I know is a little old at this point (at least one of the calls on the wear side are deprecated which I already worked around). At about 2:00 in the presenter is able to extend WearableListenerService without any issue within his phone side app and I have no idea what I am missing to be able to do that. I also did look into just trying to add the support library manually but to no avail.
Ok so, for anyone who runs into a similar issue down the road. The solution appears to be that when you create a wearable app through the new wizard and attempt to add an application module to the project, you will need to manually add the following lines to your phone app side gradle file under dependencies.
implementation 'com.google.android.gms:play-services-wearable:17.1.0'
implementation 'androidx.wear:wear:1.1.0'
This allowed the IDE to recognize the requisite classes and import them accordingly into the companion phone side application.
I am new to Xamarin and not sure if chose Xamarin.Forms to create a application for ios and android platform has a problem or not.
The application has some features below:
The application will be able to running some code in background without launching application by user.
The application can be launched by a href link or a notification.
The application is able to launch a builtin Camera application, and receive picture data from Camera application.
Thanks,
Bo
The features you are mentioning can be done with both. Actually, anything you can do on Xamarin.iOS and Xamarin.Android can be done with Forms. Because Forms is only an abstraction layer for the UI which is installed by a NuGet package.
Now, having that said when to use Forms or when to use iOS/Android? It is mostly about UI. Are you going to do some advanced or platform specific stuff is is easier to implement that with the platform specific project.
If you UI will be the same in both platforms and mostly consists of some lists and input fields, then that is a very good candidate for a Forms project.
Notice how I said it is easier to do in the platform specific projects. Again here, you can do anything in Forms as well by the means of Custom Renderers, it is just a bit harder to do.
Ideally try it out yourself and see what suits you best.
In regard with your need to execute code in the background. This will be tricky and is very dependent on the platform that you're on. You will definitely have to write platform specific code for that for which you can use the DependencyService to abstract it to your shared code.
However like AlancLui mentioned executing code in the background isn't something that is easy to do on mobile. On iOS it is restricted to accessing location data or playing music, but still your app needs to be running (in the background). Android has something called Services for this, which makes it a bit easier.
What is your approach for creating your own set of controls aka own Extensions Library? After a few years of Xpages development we have a huge set of controls that are general purpose for building UI, some web services etc. (Probably as most other developers.) When we start a new project now we have to copy the entire stuff from one database to new one which involves controls, jars, css, images, JAVA code ... and then you completely loose control to maintain some central version of this controls & codes, everything is scattered among several projects/databases and things get messy fast.
We have thought about creating our own extension library as described here
http://www-10.lotus.com/ldd/ddwiki.nsf/dx/Master_Table_of_Contents_for_XPages_Extensibility_APIs_Developer_Guide but there is not enough documentation for this topic and the entire development process is quite complicated (at least seems to me. I tried two times based on docs above going through eclipse plugin project -> feature project -> update site and still having some bugs around)
What is your experience and approach for creating and maintaining shared Xpages controls in your Domino environment? Is there some hidden feature we miss here that can help us?
Take a look at the XSP Starter Kit on OpenNTF and the XPages SDK to setup an eclipse environment for plugin development. You'll also want Eclipse IDE for RCP and RAP Developers. Install the starter kit and SDK into eclipse and you should be all set.
The starter kit is a sample plugin with all kinds of examples of phase listeners, components, etc. Once you want to deploy your plugin, create an update site from within eclipse and use the Update Site NSF available on your server install to place your update site. Once that's done, you can replicate that NSF to any other servers that may need the plugin.
For more information about the starter kit, take a look at this slide deck. There is also a github project for the starter kit. Documentation for the XPages SDK can be found here. And a video for setting up the SDK is available on youtube. Lastly, here's the documentation for setting up the update site NSF.
While we haven't gotten to that yet in XPages, our model for regular Notes design elements is to have a central template that contains the elements that are shared, with those specific design elements marked to inherit from that template. Sometimes, a database inherits design elements from two different central templates.
That way, those centrally controlled design elements remain the same in all databases.
I would recommend looking at some example's on github for how they have library/components setup. One of the more simpler examples that has just a single component built into a Library is Steve Pridemore's App Layout Extension...https://github.com/DominoDev, Another good one is Nathan Freeman's Starterkit: https://github.com/the-ntf/xspstarterkit. Hopefully these will help you get the file structure down on which files you need and how they work.
When I am creating a custom module containing my own Controllers and Views, the default project created by Code Generation creates a project that is like MVC but Visual Studio does not recognize it as an MVC project so it doesn't offer the normal "Add View" tooling as it does in a "real" MVC project.
I have seen posts talking about changing the Project type GUID in the project file but I am hoping there is an alternative to this approach. I have also seen tutorials where the presenter is using Resharper. I am currently not a Resharper user so I am not ready to adopt this approach either.
Are there project templates available? Any Code Generation module features I can take advantage of? I mainly want to find out how people are doing this now to make the development workflow go faster.
Thanks,
Brian
Yes, that's what the code generation tool does, so that we can reduce the Orchard requirements just to ASP.NET 4. Now a module is just a project and a manifest, living in a subfolder of Modules. There is nothing magical about the command-line and it's perfectly fine to create the project from VS. Or you can modify the code generation command so it adds the project type guid at creation. Both choices are valid, you just need to be aware that if there are other users than yourself, you might prevent them from opening the module in VS unless they install the MVC tooling first. That should not be a big problem, but just something to be aware of.
What would be the best practice to share busines logic c# code between MonoTouch and Mono For Android projects?
Edited:
Initially, my question was about the physical file sharing:
What do you propose to use: network file sharing or some code
version control (git, svn)? In my case I am using two workstations -
Mac (MonoDevelop with MonoTouch) and PC (Visual Studio with
MonoDroid).
What about Solution/Project folder structure? In
"Blog Post: Xamarin Mobile World Congress 2012 Unofficial
Conference App Released!" example structure is quite confusing:
several solutions in one folder and then different platform projects in one
subfolder with different folder and project names. It can not be accomplished nativly
with IDE. Are they editing content of solution files and folder names manualy
outside of IDE environment?
And for projects of common code what kind of profile (template) to
use? Monotouch has several: Empty Project, MonoTouch Library
Project and MonoTouch Binding Projects? In Android i supose -
Android class library?
This is a very general question, but here are a few resources that may help you get started:
Video: Cross-platform Mobile Development
Blog Post: Shared Libraries For Windows Phone 7, MonoDroid and Beyond
Book: Mobile Development with C#
Blog Post: Xamarin Mobile World Congress 2012 Unofficial Conference App Released!
Edit (to answer your new questions)
The idea behind linking files across projects is that there is only one actual copy of the file, rather than having to manage multiple copies and keep them in sync yourself. The file will actually exist in just one project and be linked into the others, but when the projects are compiled it treats the file as if it were actually there.
I can't speak to exactly how they created their folder structure, but I know there have been many cases where I would manually edit project or solution files to get the folder structure I want, because there was no way to get what I wanted through the IDE alone. This really boils down to personal preference on how you want your folders to be structured.
In the end, what you need is a class library project for every platform you want to target. When going with the linked file approach, it's totally up to you where you put the physical files. One approach I use often is to actually create a standard .NET 4.0 class library, put the files in there, and then link them into my Mono for Android and MonoTouch class libraries. If all you care about is targeting iOS and Android, that may be more trouble than it's worth, and you can just let the files live in one project and link them into the other.
Disclaimer: I've got a particular Mvvm methodology that I use for sharing code across multi-platform projects...
Despite this, I genuinely don't believe in "one size fits all" frameworks - I think you need to be careful to pick an approach that best suits your project, your developers and your organisation.
With that said, some of the tools you can use within the Mono development approach are:
using Portable Class Libraries to share exactly the same code between platforms
using platform specific Class Libraries to share code between platforms, linking these using the Project Linker tool from Microsoft
using #define code within your class libraries to provide platform specific implementations of the projects (I personally try to avoid this approach, but it does often provide the quickest route to market)
using DI/IoC techniques to provide components for those occasions when platform specific implementations really are required.
using a assembly linking to provide IoC - e.g. this is what the Xamarin MobileAPI does
using server-based logic for genuine shared functionality - e.g. using REST or SOAP-XML services to implement logic
sharing tests (e.g. NUnit) between platforms to assure the quality of your logic
using shared code techniques - MVC (MonoCross) or MVVM (MonoMobile.Views or MvvmCross) for UI "controller" logic; MonoTouch.Dialog and MonoDroid.Dialog for "View-level" abstractions; CrossGraphics for UI "drawing"; SQLite.Net for database; etc.
I'm finding the MonoTouch, MonoDroid and the Microsoft tools provide real and signigicant benefits in developing cross platform code - but you do have to work and think to achieve this.